Archive

Posts Tagged ‘databases’

Magiq to Entities – An update

May 7, 2011 2 comments

The past days I’ve been working on making Magiq work with Entity Framework.

First I tried to work with the MetadataWorkspace and I gave up, ’cause its really impossible to get the mapping information. Luckily, I found Linq to Edmx project who does exactly what I needed.

Then I had some troubles working with the Queryables generated by the ObjectSets. Basically, the expression generated calls methods that doesn’t work and are there only to give information in the expression. So the expression is not something you can compile and execute. As big part of Magiq is to manipulate expression trees, that was a really big problem. I needed to figure out how to change the source queryable (I mean, the queryable where all the methods are applied to) to a simple ObjectSet. Besides it works now, I’m still working to get to a nicer way (you don’t want to know what I have done to make it work…).

Since I changed the insert API from having the new item expression (the new{…}) outside to have it as a select, I had to break the query in two, the select and the “rest”. Ok, that gave me more headaches :).

But the biggest problem was when Entity Framework started to change the order of the columns in the select (and add new columns). Let me explain how Linq to Sql works:

If you do this:

items.Where( ... ).Select( x => new { A = x.Prop1, B = x.Prop2, C = x.Prop2 /*again*/ });

Linq to sql transate it to:

SELECT prop1, prop2, prop2 FROM items WHERE ...

But Entity Framework removes the repeated columns and maybe reorders them, giving you something like:

SELECT prop2, prop1 FROM items WHERE ...

You don’t have any idea of the reflection tricks I had to make to get those property-select columns mapping.

But well, those are not bad news at all. I mean I could work around them and I can say Magiq now supports Entity Framework (with a few restrictions). Those are:

  • Only Table per class hierarchy inheritance is supported. I’m currently working on the Table per concrete class and Table per type strategies
  • Only mapped associations are supported. This means associations based on foreign keys are not (yet).
  • Only mapped POCOs are supported. This means Self Tracking entities and Code First are not (yet).

Keep in touch for the updates 🙂

Magiq: New release and API Changes

April 28, 2011 Leave a comment

New release of Magiq, supporting Linq-to-sql. This should be the last one for Linq-to-sql, the next one I hope will have the minimal support for Entity Framework. You can download it from here.

For those reading this for the first time (?), Magiq is a framework that let you do mass operation in a Linq fashion.

So… as Magiq will be supporting Entity Framework soon, it made sense to change the API to make it support Entity Framework limitations. Also, I found a better Insert API (the one that always made me doubt!). The changes are:

Query extension method changes
The new method looks like this:

country.Query(x => x.Cities); 

It will return an IQueryable that will let you do all the Magiq stuff.

No more IEnumerable support
This is a hard one. You can only do Magiq stuff between IQueryables. If you have an IEnumerable collection, use the Query extension method of it parent entity.

New Insert API

destination.Insert( source.Where( condition ).Select( new Item{ ... } ));

Cool, isn’t it? 🙂

Entities extension methods
Because we no longer support extension methods over collections but over the entity, there are some extension methods for improving the code readavility.

Delete

entity.Delete(x => x.Collection.Where( condition ));
//Instead of 
entity.Query(x => x.Collection).Where( condition ).Delete();

Update

entity.Update(x => x.Collection.Where( condition ).Set(x => x.Prop, value));
//Instead of 
entity.Query(x => x.Collection).Where( condition ).Set(x => x.Prop, value).Update();

Query

entity.Query(x => x.Collection.Where( condition ));
//Instead of 
entity.Query(x => x.Collection).Where( condition );

Insert

entity.InsertInto( x => x.Collection, source.Where( condition ).Select( new Item{ ... } ));
//Instead of
entity.Query(x => x.Collection)
      .Insert( source.Where( condition ).Select( new Item{ ... } ));

MemoDb 0.1.0 alpha released!

February 11, 2011 Leave a comment

The first release of MemoDb is out!
It supports:

  • Inserts
  • Updates
  • Delete
  • Insert references and collections by cascade
  • Delete collection children by cascade (aka cascade-all-delete-orphans)
  • EntityRef references
  • Id auto generation (With defaults for ints, long and guid)

You can download it from here.

To see other posts of MemoDb:

MemoDb: Cascades and Collections support

February 10, 2011 Leave a comment

I’ve been implementing some new features and I think it’s ready for an alpha release. I’ll be uploading the files in codeplex.

To follow the MemoDb posts saga:

Now, MemoDb supports:

  • Delete
  • Collections
  • EntityRef (for LinqToSql support)
  • Cascade inserts
  • Cascade delete on collections children (aka all-delete-orphans)

Delete
Pretty simple, it let you delete objects:

using (var s = memo.CreateSession())
{
	var city= s.GetById<City>(1);
	s.Delete(city);
	s.Flush();
}

Cascade Inserts
You can configure MemoDb to insert new references by default:

var memo = new Memo(insertByCascadeByDefault: true)

Or you can specify the behaviour just for one relationship:

 var memo = new Memo()
           .Map<City>(c => c.CasacadeInsert(x => x.Country))
           .Map<Country>();

Cascade Delete Orphans
You can configure MemoDb to delete collections children by cascade when the parent object is deleted by default:

var memo = new Memo(deleteOrphansByCascadeByDefault: true)

Or you can specify the behaviour just for one collection:

 var memo = new Memo()
           .Map<City>()
           .Map<Country>(c => c.CasacadeDeleteOrphans(x => x.Cities));

MemoDb: Auto assign id support

February 4, 2011 Leave a comment

MemoDb is a in-memory-linq-database useful for mocking linq repositories in unit testing. You can track the previous posts:

Today I will talk about the generation of ids for new entities. As MemoDb stands for mocking real linq orms and, generally, the underlying databases auto assign the ids.

var memo = new Memo()
     .Map<MyEntity>(x=>x.Id(x => x.Id, autoAssign: true));

By now, MemoDb supports:

  • Int32: increments the last id.
  • Int64: increments the last id.
  • Guid: Generates a new Guid.

If you need another strategy or to map another id type, you can specify the strategy as a delegate:

var memo = new Memo()
     .Map<MyEntity>(x=>x.Id(x => x.Id, last => last + 10));

In the example above, the generation is made adding 10 to the last id assigned.
By default, MemoDb will assign the ids when the object is inserted. You can override this behavior by configuration:

var memo = new Memo(assignIdMode: AssignIdMode.OnFlush)
     .Map<MyEntity>();

MemoDb: Collections support

February 4, 2011 Leave a comment

MemoDb is a in-memory-linq-database useful for mocking linq repositories in unit testing.
Now it understand how to store collections. The strategy is pretty simple:

  • For class collections (Arraylist, List, Hashtable, etc.) it will construct one of those and add each item. It only works with classes that have a parameterless constructor.
  • For interfaces collections (IList, IList, IDictionary, etc.) it will construct an ArrayList, List, Hashtable or Dictionary according the interface.

You can download the last version from: http://memodb.codeplex.com/

Introduction to MemoDb

February 3, 2011 Leave a comment

I’m working on an internal framework on the company I work (it will be open source soon I expect to post a lot in the future about it) that needs the ability of mocking a repository with a memory database. Since this repository works with Linq, an implementation with a List inside was enough.
The time passed and we realize that it will be really usefull to have transactions in that repository (ok, not so usefull, but at least funny 🙂 ). So I started to work on MemoDb.
The source code of the first version is in http://memodb.codeplex.com.

Let’s show some examples:

var memo = new Memo()
				.Map<City>();


using (var s = memo.CreateSession())
{
	s.Insert(new City
				 {
					 Id = 1,
					 Name = "Buenos Aires"
				 });
	s.Insert(new City
				 {
					 Id = 2,
					 Name = "New York"
				 });
	s.Insert(new City
				 {
					 Id = 3,
					 Name = "Montevideo"
				 });
	s.Insert(new City
				 {
					 Id = 4,
					 Name = "Bogotá"
				 });
	s.Flush();
	s.Insert(new City
				 {
					 Id = 5,
					 Name = "Bangkok"
				 });

}

using (var s = memo.CreateSession())
{
	var cities = s.Query<City>().Where(x => x.Name.StartsWith("B"));

	Assert.AreEqual(2, cities.Count());
}

Note that it doesn’t store Bankgok.

var memo = new Memo()
				.Map<City>();

var buenosAires = new City
{
	Id = 1,
	Name = "Buenos Aires"
};
using (var s = memo.CreateSession())
{
	s.Insert(buenosAires);
	s.Flush();
}

City buenosAires2;

using (var s = memo.CreateSession())
{
	var test = s.GetById<City>(buenosAires.Id);
	test.Name = "Bs As"; //Not flushed!
}

using (var s = memo.CreateSession())
{
	buenosAires2 = s.GetById<City>(buenosAires.Id);
}

Assert.AreEqual("Buenos Aires", buenosAires2.Name);

Right now it supports:

  • Inserts
  • Updates of dirty objects
  • Many-to-one relationships
  • Queries

Next steps:

  • Delete
  • Collection management
  • Id generation strategies
  • Cascade

In future posts I will be talking about the implementation details.

Categories: C#, MemoDb Tags: , , , ,