public void FromFields_New_Record_Ids()
{
var fields = new string[][]
{
new string[] { "Column0", "Column1", "Column2" },
new string[] { "Row0Value0", "Row0Value1", "Row0Value2" },
new string[] { "Row1Value0", "Row1Value1", "Row1Value2" }
};
var target = XDatabase.FromFields("Test", fields);
Assert.Equal(3, target.Columns.Length);
Assert.Equal("Column0", target.Columns[0].Name);
Assert.Equal("Column1", target.Columns[1].Name);
Assert.Equal("Column2", target.Columns[2].Name);
Assert.Equal(2, target.Records.Length);
Assert.Equal("Row0Value0", target.Records[0].Values[0].Content);
Assert.Equal("Row0Value1", target.Records[0].Values[1].Content);
Assert.Equal("Row0Value2", target.Records[0].Values[2].Content);
Assert.Equal("Row1Value0", target.Records[1].Values[0].Content);
Assert.Equal("Row1Value1", target.Records[1].Values[1].Content);
Assert.Equal("Row1Value2", target.Records[1].Values[2].Content);
}
public void FromFields_Existing_Record_Ids()
{
var fields = new string[][]
{
new string[] { "Id", "Column0", "Column1", "Column2" },
new string[] { "75080d72-734d-4187-a38f-9860df375a2a", "Row0Value0", "Row0Value1", "Row0Value2" },
new string[] { "547fe8cf-b3ab-4abb-843b-acb3df0f7ad1", "Row1Value0", "Row1Value1", "Row1Value2" }
};
var target = XDatabase.FromFields("Test", fields, "Id");
Assert.Equal("Id", target.IdColumnName);
Assert.Equal(4, target.Columns.Length);
Assert.Equal("Id", target.Columns[0].Name);
Assert.Equal("Column0", target.Columns[1].Name);
Assert.Equal("Column1", target.Columns[2].Name);
Assert.Equal("Column2", target.Columns[3].Name);
Assert.Equal(2, target.Records.Length);
Assert.Equal("75080d72-734d-4187-a38f-9860df375a2a", target.Records[0].Id.ToString());
Assert.Equal("547fe8cf-b3ab-4abb-843b-acb3df0f7ad1", target.Records[1].Id.ToString());
}
/// <summary>
/// 更新 添加
/// </summary>
public static bool Update <TSource>(TSource t)
{
using (XDatabase db = XDatabase.Open(baseDir)) {
db.Store(t);
return(true);
}
return(false);
}
/// <summary>
/// Remove database.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="db">The <see cref="XDatabase"/> to remove.</param>
public static void RemoveDatabase(this XProject project, XDatabase db)
{
if (project?.Databases != null && db != null)
{
var previous = project.Databases;
var next = project.Databases.Remove(db);
project?.History?.Snapshot(previous, next, (p) => project.Databases = p);
project.Databases = next;
}
}
/// <summary>
/// Add column to database columns collection.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="db">The database instance.</param>
/// <param name="column">The column instance.</param>
public static void AddColumn(this XProject project, XDatabase db, XColumn column)
{
if (db?.Columns != null && column != null)
{
var previous = db.Columns;
var next = db.Columns.Add(column);
project?.History?.Snapshot(previous, next, (p) => db.Columns = p);
db.Columns = next;
}
}
/// <summary>
/// Add record to database records collection.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="db">The database instance.</param>
/// <param name="record">The record instance.</param>
public static void AddRecord(this XProject project, XDatabase db, XRecord record)
{
if (db?.Records != null)
{
var previous = db.Records;
var next = db.Records.Add(record);
project?.History?.Snapshot(previous, next, (p) => db.Records = p);
db.Records = next;
}
}
public XDatabase Parse(string input)
{
input = Regex.Replace(input, @"\s+", string.Empty);
var tokens = tokenizer.Tokenize(input);
var db = new XDatabase();
ParseBody(tokens, db);
return(db);
}
public void Update_Destination()
{
var destinationFields = new string[][]
{
new string[] { "Column0", "Column1", "Column2" },
new string[] { "Row0Value0", "Row0Value1", "Row0Value2" },
new string[] { "Row1Value0", "Row1Value1", "Row1Value2" },
new string[] { "Row2Value0", "Row2Value1", "Row2Value2" }
};
var destination = XDatabase.FromFields("Destination", destinationFields, "Id");
var sourceFields = new string[][]
{
new string[] { "Id", "Column0", "Column1", "Column2" },
// Existing record 0 and 1 values will be updated.
new string[] { destination.Records[0].Id.ToString(), "Row0Value0Update", "Row0Value1Update", "Row0Value2Update" },
new string[] { destination.Records[1].Id.ToString(), "Row1Value0", "Row1Value1", "Row1Value2" },
// Existing record 2 will be removed if not present in source.
// New record will be added.
new string[] { "e450006a-cda2-46fc-b475-89335a87e2f8", "Row3Value0", "Row3Value1", "Row3Value2" },
// New record will be added.
new string[] { "410b0378-8ea5-4a21-8260-9aa929b2a57b", "Row4Value0", "Row4Value1", "Row4Value2" }
};
var source = XDatabase.FromFields("Source", sourceFields, "Id");
ImmutableArray <XRecord> .Builder target;
bool isDirty = XDatabase.Update(destination, source, out target);
Assert.True(isDirty);
Assert.NotNull(target);
Assert.Equal(4, target.Count);
Assert.Equal(destination.Records[0].Id.ToString(), target[0].Id.ToString());
Assert.Equal("Row0Value0Update", target[0].Values[0].Content);
Assert.Equal("Row0Value1Update", target[0].Values[1].Content);
Assert.Equal("Row0Value2Update", target[0].Values[2].Content);
Assert.Equal(destination.Records[1].Id.ToString(), target[1].Id.ToString());
Assert.Equal("Row1Value0", target[1].Values[0].Content);
Assert.Equal("Row1Value1", target[1].Values[1].Content);
Assert.Equal("Row1Value2", target[1].Values[2].Content);
Assert.Equal("e450006a-cda2-46fc-b475-89335a87e2f8", target[2].Id.ToString());
Assert.Equal("Row3Value0", target[2].Values[0].Content);
Assert.Equal("Row3Value1", target[2].Values[1].Content);
Assert.Equal("Row3Value2", target[2].Values[2].Content);
Assert.Equal("410b0378-8ea5-4a21-8260-9aa929b2a57b", target[3].Id.ToString());
Assert.Equal("Row4Value0", target[3].Values[0].Content);
Assert.Equal("Row4Value1", target[3].Values[1].Content);
Assert.Equal("Row4Value2", target[3].Values[2].Content);
}
public static bool Delete <TSource>(TSource t)
{
using (XDatabase db = XDatabase.Open(baseDir)) {
var query = db.Query <TSource>();
if (query != null)
{
db.Delete(t);
return(true);
}
}
return(false);
}
public void SetCurrentDatabase_Sets_CurrentDatabase()
{
var target = new XProject();
var db = XDatabase.Create("Db");
target.Databases = target.Databases.Add(db);
target.SetCurrentDatabase(db);
Assert.Equal(db, target.CurrentDatabase);
}
public static bool Delete <TSource>(Func <TSource, bool> predicate)
{
using (XDatabase db = XDatabase.Open(baseDir)) {
var query = db.Query <TSource>();
if (query != null)
{
var model = query.Where <TSource>(predicate).SingleOrDefault();
db.Delete(model);
return(true);
}
}
return(false);
}
/// <summary>
/// 数据获取
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <param name="predicate"></param>
/// <returns></returns>
public static List <TSource> GetList <TSource>(Func <TSource, bool> predicate)
{
List <TSource> list = new List <TSource>();
using (XDatabase db = XDatabase.Open(baseDir)) {
var query = db.Query <TSource>();
if (query != null)
{
list = query.Where <TSource>(predicate).ToList();
}
}
return(list);
}
/// <summary>
/// 更新 添加
/// </summary>
public static bool Update <TSource>(TSource t)
{
using (XDatabase db = XDatabase.Open(baseDir)) {
db.Store(t);
return(true);
//var query = db.Query<TSource>();
//if (query != null) {
// db.Store(t);
// return true;
//}
}
return(false);
}
private void StopObservingColumns(XDatabase database)
{
if (database == null || database.Columns == null)
{
return;
}
foreach (var column in database.Columns)
{
column.PropertyChanged -= ColumnObserver;
}
database.PropertyChanged -= DatabaseObserver;
}
public XPredicate ParseTarget(string input, XDatabase db)
{
input = Regex.Replace(input, @"\s+", string.Empty);
if (string.IsNullOrEmpty(input))
{
throw new ArgumentException("No target");
}
var tokens = tokenizer.Tokenize(input);
ParsePredicate(tokens, 0, tokens.Count, db, out XPredicate predicate);
return(predicate);
}
/// <summary>
/// Per gli script viene utilizzato un Clone del DataAccess
/// perché l'esecuzione di comandi come quoted ansi on/off causa
/// l'unprepare implicito di comandi precedentemente preparati.
/// </summary>
private bool EseguiScript(string script)
{
try {
StringBuilder sb = XFile.LeggiTestoScript(script);
if (!XDatabase.RUN_SCRIPT(ConnClone, sb))
{
ShowMsg("Errore nell'esecuzione dello script " + script, ConnClone.LastError);
return(false);
}
return(true);
}
catch (Exception E) {
ShowMsg("Errore nell'esecuzione dello script " + script, E.Message);
return(false);
}
}
internal XLogWriter(XDatabase database)
{
this.db = database;
string str = Path.Combine(this.db.FullName, "SystemLogs");
string str2 = DateTime.Now.ToString("yyyy-MM-dd");
this.logFile = Path.Combine(str, string.Format("{0}.xml", str2));
Directory.CreateDirectory(str);
if (!File.Exists(this.logFile))
{
this.doc = new XDocument(new object[] { new XElement("XMLDatabase-SystemLogs", new object[] { new XAttribute("Date", str2), new XAttribute("EngineVersion", this.db.Version) }) });
this.doc.Save(this.logFile);
}
else
{
this.doc = XDocument.Load(this.logFile);
}
}
void GetStartupClasses()
{
this.comboStartupObject.Items.Clear();
this.comboStartupObject.Items.Add(DefaultValue);
var prjfile = ParentPropertyPage.ProjectMgr.ProjectFile;
var list = XDatabase.GetStartupClasses(System.IO.Path.GetFileName(prjfile));
foreach (var item in list)
{
this.comboStartupObject.Items.Add(item);
}
if (comboStartupObject.Items.Count == 1)
{
comboStartupObject.SelectedItem = DefaultValue;
this.comboStartupObject.Items.Add("");
comboStartupObject.Enabled = false;
}
}
static void Main(string[] args)
{
string eddnbasedir = args[0];
string edsmbasedir = args.Length >= 2 ? args[1] : ".";
BodyDatabase.Init();
if (BodyDatabase.SystemCount() < 154700)
{
BodyDatabase.LoadNamedSystems("NamedSystems.json");
}
BodyDatabase.LoadEDSMSystemsLocal(System.IO.Path.Combine(edsmbasedir, "systemsWithCoordinates.jsonl"));
XDatabase.CheckScanBaseHashes();
BodyDatabase.LoadNamedBodiesLocal("NamedBodies.tsv");
// Process 3.x entries, excluding 3.0.3
XDatabase.ProcessScans(XDatabase.ReadEDDNBodiesFromDir(eddnbasedir,
"Journal.Scan-2018-02-2?.jsonl.bz2",
"Journal.Scan-2018-03-*.jsonl.bz2",
"Journal.Scan-2018-04-*.jsonl.bz2",
"Journal.Scan-2018-05-*.jsonl.bz2",
"Journal.Scan-2018-06-*.jsonl.bz2",
"Journal.Scan-2018-07-*.jsonl.bz2",
"Journal.Scan-2018-08-*.jsonl.bz2",
"Journal.Scan-2018-09-*.jsonl.bz2",
"Journal.Scan-2018-10-*.jsonl.bz2",
"Journal.Scan-2018-11-*.jsonl.bz2",
"Journal.Scan-2018-12-*.jsonl.bz2"
), true, true, true, true, true);
// Process entries without BodyID / SystemAddress
XDatabase.ProcessScans(XDatabase.ReadEDDNBodiesFromDir(eddnbasedir, "Journal.Scan-2018-*.jsonl.bz2"), true, true, true, false, true);
// Process entries without BodyID / SystemAddress / Luminosity / Composition
XDatabase.ProcessScans(XDatabase.ReadEDDNBodiesFromDir(eddnbasedir, "Journal.Scan-*.jsonl.bz2"), true, false, false, false, true);
// Process entries without BodyID / SystemAddress / Luminosity / Composition / AxialTilt
XDatabase.ProcessScans(XDatabase.ReadEDDNBodiesFromDir(eddnbasedir, "Journal.Scan-*.jsonl.bz2"), false, false, false, false, true);
// Process 3.0.3 entries
XDatabase.ProcessScans(XDatabase.ReadEDDNBodiesFromDir(eddnbasedir, "Journal.Scan-2018-*.jsonl.bz2"), true, true, true, true, false);
// Process everything else
XDatabase.ProcessScans(XDatabase.ReadEDDNBodiesFromDir(eddnbasedir, "Journal.Scan-*.jsonl.bz2"), false, false, false, false, false);
}
private void Add(XDatabase database)
{
if (database == null)
{
return;
}
database.PropertyChanged += ObserveDatabase;
if (database.Columns != null)
{
Add(database.Columns);
}
if (database.Records != null)
{
Add(database.Records);
}
}
private void Remove(XDatabase database)
{
if (database == null)
{
return;
}
database.PropertyChanged -= ObserveDatabase;
if (database.Columns != null)
{
Remove(database.Columns);
}
if (database.Records != null)
{
Remove(database.Records);
}
}
protected void Page_Load(object sender, EventArgs e)
{
using (var db = XDatabase.Open(Server.MapPath("~/test")))
{
var data = new Employee()
{
EmployeeId = 1,
FirstName = "ares",
LastName = "chen",
Title = "CEO"
};
db.Store(data);
gd.DataSource = db.Query <Employee>();
gd.DataBind();
}
}
/// <summary>
/// Update the destination database using data from source database.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="destination">The destination database.</param>
/// <param name="source">The source database.</param>
public static void UpdateDatabase(this XProject project, XDatabase destination, XDatabase source)
{
if (destination != null && source != null)
{
ImmutableArray <XRecord> .Builder records;
bool isDirty = XDatabase.Update(destination, source, out records);
if (isDirty && records != null)
{
var builder = project.Databases.ToBuilder();
var index = builder.IndexOf(destination);
destination.Records = records.ToImmutable();
builder[index] = destination;
var previous = project.Databases;
var next = builder.ToImmutable();
project?.History?.Snapshot(previous, next, (p) => project.Databases = p);
project.Databases = next;
}
}
}
private void ParseBody(List <XToken <XTokenType> > tokens, XDatabase db)
{
if (tokens.Count > 0)
{
if (tokens[0].Type == XTokenType.PredicateBlock)
{
int end = tokens.Count;
bool hasClauses = false;
for (int i = 1; i < tokens.Count; ++i)
{
if (tokens[i].Type == XTokenType.ClauseBlock)
{
hasClauses = true;
end = i;
break;
}
}
if (tokens.Count == 1)
{
throw new ApplicationException("No available predicates");
}
ParseSignatures(tokens, 1, end, db);
++end;
if (hasClauses)
{
ParseClauses(tokens, end, tokens.Count, db);
}
}
else
{
throw new ApplicationException("Missing the predicate block");
}
}
}
public void Records_Not_Null()
{
var target = new XDatabase();
Assert.NotNull(target.Records);
}
public void Columns_Not_Null()
{
var target = new XDatabase();
Assert.NotNull(target.Columns);
}
public void Inherits_From_ObservableObject()
{
var target = new XDatabase();
Assert.True(target is ObservableObject);
}
private int ParseClause(List <XToken <XTokenType> > tokens, int start, int end, XDatabase db)
{
int position = ParsePredicate(tokens, start, end, db, out XPredicate predicate);
if (tokens[position].Type == XTokenType.Dot)
{
db.Clauses.Add(new XClause(null, predicate));
return(++position);
}
if (tokens[position++].Type != XTokenType.Assignment)
{
throw new ApplicationException("Invalid clause syntax");
}
position = ParseExpression(tokens, position, end, db, out IXExpression expression);
if (position == end || tokens[position++].Type != XTokenType.Dot)
{
throw new ApplicationException("Not terminated clause");
}
db.Clauses.Add(new XClause(expression, predicate));
return(position);
}
static void Main(string[] args)
{
//这个程序演示了XmlDatabase的简单使用方式.注意，目前的版本是alpha，后续可能还会有所更改
//第一步：创建或者打开一个数据库
using (XDatabase db = XDatabase.Open("Test"))
{
//如果要重定向日志输出，请使用下面的语法即可
db.Log = Console.Out;
#region //第二步：创建几个数据实体类型.
//值得说明一下，这些数据实体类型没有任何特殊的要求，不需要添加任何的Attribute。但最好是遵守以下的两条简单的规则
//1.属性都是可读可写的，都是Public的
//2.重写ToString方法，这是为了让引擎在做日志记录的时候用的
Customer customer = new Customer()
{
CustomerID = "ALFKI",
CompanyName = "Alfreds Futterkiste",
Country = "Germany",
Region = "BC",
City = "Berlin",
ContactName = "Maria Anders",
Address = "Obere Str. 57"
};
Employee employee = new Employee()
{
EmployeeId = 1,
FirstName = "Nancy",
LastName = "Davolio",
Title = "Sales Representative"
};
Product product = new Product()
{
ProductId = 1,
ProductName = "Chai"
};
Order Order = new Order()
{
OrderID = 10248,
OrderDate = DateTime.Now,
Customer = customer,
Employee = employee,
OrderItems = new List <OrderItem>()
{
new OrderItem()
{
Product = product,
UnitPrice = 20.5m,
Quantity = 3
},
new OrderItem()
{
Product = new Product()
{
ProductId = 2,
ProductName = "Grandma's Boysenberry Spread"
},
UnitPrice = 333,
Quantity = 1
}
}
};
#endregion
//第三步：插入对象
db.Store(Order);//只要调用该方法就可以了。默认情况下，这是立即生效的
//第四步：读取对象 （这里还可以做任何的LINQ查询操作）
var query = from o in db.Query <Order>()
where o.OrderID == 10248
select o;
Order firstOrder = query.First();
Console.WriteLine("{0},总金额为:{1}", firstOrder, firstOrder.OrderItems.Sum(i => i.Quantity * i.UnitPrice));
//第五步：更新对象
firstOrder.OrderID = 10249;//假设我们修改一下订单编号
//你还可以对该对象做任何的修改，例如增加一个订单记录
firstOrder.OrderItems.Add(new OrderItem()
{
Product = new Product()
{
ProductId = 3, ProductName = "Mishi Kobe Niku"
},
UnitPrice = 10000,
Quantity = 1
});
db.Store(firstOrder);//更新的语法与刚才插入的时候是一模一样的，内部会判断出来到底是更新还是新增
Console.WriteLine("{0},总金额为:{1}", firstOrder, firstOrder.OrderItems.Sum(i => i.Quantity * i.UnitPrice));
//第六步：删除对象
db.Delete(firstOrder);
//第七步：批处理（上面的操作都是立即生效的，如果操作数不多的话，很简单也很直接，但因为每次都涉及到数据文件的读写，如果我们有一个循环，要批量做一些事情，则可能会有性能方面的问题，所以下面提供了批处理模式）
//首先得将数据库的模式切换到批处理模式
db.AutoSubmitMode = false;
for (int i = 0; i < 10; i++)
{
Order temp = new Order()
{
OrderID = 10248,
OrderDate = DateTime.Now,
Customer = customer,
Employee = employee,
OrderItems = new List <OrderItem>()
{
new OrderItem()
{
Product = product,
UnitPrice = 20.5m,
Quantity = 3
},
new OrderItem()
{
Product = new Product()
{
ProductId = 2,
ProductName = "Grandma's Boysenberry Spread"
},
UnitPrice = 333,
Quantity = 1
}
}
};
db.Store(temp);//语法还是一模一样的
}
//区别在于，如果是批处理模式，则必须明确地调用SubmitChanges才生效
XSubmitStatus status = db.SubmitChanges();
//这个SubmitChanges方法默认情况下，如果遇到某个操作出错，那么后面的操作就不会进行了。
//如果希望出错后继续，那么应该使用下面的语法
//XSubmitStatus status=db.SubmitChanges(true);
//第八步：事务性操作
//要进行事务性操作，必须处于批处理模式中。我最后将它做了简化，调用下面的方法即可
//XSubmitStatus status = db.SubmitChangesWithTransaction();
//第九步：关闭数据库
db.Close();
}
Console.Read();
//后续任务
}
private void ParseSignatures(List <XToken <XTokenType> > tokens, int start, int end, XDatabase db)
{
for (int i = start; i < end;)
{
i = ParseSignature(tokens, i, end, db);
}
}
private int ParseSignature(List <XToken <XTokenType> > tokens, int start, int end, XDatabase db)
{
int position = start;
if (tokens[position].Type == XTokenType.Name)
{
string name = tokens[position++].Value;
if (position < end && tokens[position++].Type == XTokenType.LBrace)
{
int arity = 0;
if (position < end && tokens[position].Type == XTokenType.Arity)
{
arity = int.Parse(tokens[position].Value);
++position;
}
if (position < end && tokens[position++].Type == XTokenType.RBrace)
{
foreach (var s in db.Signatures)
{
if (s.Name == name)
{
throw new ApplicationException("Redefinition of the signature");
}
}
db.Signatures.Add(new XSignature(name, arity));
return(position);
}
}
}
throw new ApplicationException("Invalid signature syntax");
}
public XTaskManager(XDatabase db)
{
this.tasks = new List<XChangeItem>();
this.internaldb = db;
}
internal XTransaction(XDatabase db)
{
this.database = db;
}
