DeNSo DB is out

DensoDB is a new NoSQL document database. Written for .Net environment in c# language.
It’s simple, fast and reliable. More details on github https://github.com/teamdev/DensoDB

You can use it in three different ways:

  1. InProcess: No need of service installation and communication protocol. The fastest way to use it. You have direct access to the DataBase memory and you can manipulate objects and data in a very fast way.
  2. As a Service: Installed as Windows Service, it can be used as a network document store.You can use rest service or wcf service to access it. It’s not different from the previuos way to use it but you have a networking protocol and so it’s not fast as the previous one.
  3. On a Mesh: mixing the previous two usage mode with a P2P mesh network, it can be easily syncronizable with other mesh nodes. It gives you the power of a distributed scalable fast database, in a server or server-less environment.

You can use it as a database for a stand alone application or in a mesh to share data in a social application. The P2P protocol for your application and syncronization rules will be transparet for you, and you’ll be able to develop all yor application as it’s stand-alone and connected only to a local DB.

Features

  1. Journaled
  2. Built using Command Query Responsibility Segregation pattern in mind.
  3. Store data as Bson-like Documents.
  4. Accessible via Rest
  5. Accessible via WCF
  6. Peer to peer syncronization and event propagation enabled.
  7. Pluggable via Server Plugin.
  8. Use Linq syntax for queries.

The Theory

A document database is a Database where data are stored as they are. Usually there is no need to normalize or change their structure, so it’s optimal for domain driven design, because you’ll not need to think about how to persist your domain.

A document is stored in BSon-like format A document is self contained, and all you needed to understand it’s information are in the document itself. So you will not need additional query to understand foreign key or lookup table datas.

You can have collections of document. Collection are not tables, you can think to collections as sets of documents, categorized in the same way. A collection is schema-free and you can store different kind of documents in the same collection.

Every document in every collection is classified using a Unique Identifier. The DB will use the UID to store and to access every document directly.

You can store your data in DeNSo using a Bson document or, more easly you can store your entities in DeNSo.

DeNSo has a Bson De/Serializer able to traduce virtually every entity in a BSon Document and vice-versa.

 

 

https://github.com/teamdev/DensoDB

Scala comes to .Net

Miguel Garcia, part of the Scala group at EPFL, has been striving to make the Scala productivity available to .Net developers too. In a project funded by Microsoft, he has now reached a major milestone in delivering that capability. In this interview Miguel tells you how you can now use Scala on .Net and gives an insight into the way this challenging project has been achieved and the future direction.

 

Official announce 

Webinars developing .NET and C# applications for VoltDB

VoltDB’s rich .NET C# client library provides high-performance, and native support for Windows-based clients. After a primer on the basics of building C# WinForm applications and services backed by a VoltDB database cluster, the presentation dives into specific topics such as advanced UI integration and DataBinding. As a practical example, we unveil a new “mini-SQL Management Studio” for VoltDB built entirely in C# and leveraging the VoltDB .NET client library.

 

Access VoltDB webinars  on Developing .NET and C# applications for VoltDB

 

MongoDB, OpenStreetMap and a Little Demo

Original article from http://openmymind.net/2011/6/20/MongoDB–OpenStreetMap-and-a-Little-Demo

I had an idea. Before I realized how bad the idea was, I did stumble upon the open geographic database provided by OpenStreetMap. I have a pretty good feeling that everyone else has known about this for years, but for me it was like my first christmas.

I was curious in finding worldwide points of interest, and I quickly found the OpenStreetMap database. The complete database is available as a 16GB compressed XML file (which comes in at around 250gb uncompressed), which is updated daily by generous contributors. Thankfully, you can find mirrors that have partitioned the data in some meaningful way (like by major cities).

For our needs, the data is made up of few important elements. The first is a node, which has a longitude, latitude and an id. A node has zero or more tag child-elements, which are key-value pairs of meta data. There’s also a way element which references multiple node elements. You see, in my naive mind a point of interest like a building would be represented by a single node. However, from a mapping point of view, it’s really a polygon made up of multiple nodes. A way can also have zero or more tags.

Now ever since I wrote the MongoDB Geospatial tutorial, I’ve had an itch to try more real-world stuff with MongoDB’s geo capabilities. This database seemed like an ideal candidate. The first thing I did was download a bunch of city-dumps from a mirror and started writing a C# importer (github). I wasn’t actually interested in polygons, so I calculated the centroid of any way and converted it into a node. Most of the time the result was quite good. The importer’s readme has more information.

Next, I wrote a little Sinatra app and did the obvious thing using the Google Maps API. You can also find the source for this on github.

I’ve put up a demo at pots.mongly.com

I also extracted the data for each city and made it available, so that you can play with it yourself. It’s available atdata.mongly.com (you can read about OpenStreetMap’s licensing here). The data is meant to be easily imported into mongodb using its mongoimport command. Download a city, extract it, and do the following:

1
2
mongoimport -d pots -c tags PATH_TO_TAGS.json
mongoimport -d pots -c nodes PATH_TO_COUNTRY.json

If mongoimport isn’t in your PATH, you’ll need to use the full path. Also, the tags.json file is the same for all cities – so you only need to import it once. Finally, connect to mongodb, type use pots and then create a 2D index on the loc field: db.nodes.ensureIndex({loc: '2d'})

Different cities have different amounts of data. I left everything in and you can see there’s quite a bit of information. Given that MongoDB supports composite indexes, it’d be trivial to provide additional node filtering.

And that’s why, when people ask me What did you do this weekend?, I can say I parsed a 250gb XML file (because, yes, I did download it and I did *try* to import it)

 

 

MongoDB 1.8.2 released

MongoDB 1.8.2 has been released.
This is the latest release in the 1.8 stable branch.
This is a recommended upgrade for anyone running 1.8.x

Notable changes:

  • slaveOk fix in mongos
  • concurrency improvements in mongos
  • replica set status message thread safey

Downloads: http://www.mongodb.org/downloads
Change Log: https://jira.mongodb.org/browse/SERVER/fixforversion/10263

 

In addition, the C# driver version 1.1 has also been released;

here are a number of improvements and bug fixes since the 1.0
version. There are a few cases where breaking changes were made, but
they are mostly low level and we expect that very few of you will be
affected by them. In any case, be aware of this when switching to
version 1.1 and make sure you have time to resolve any compilation
errors that may arise and to test your application. We will monitor
this group even more closely the next few days in case any of you have
any questions. See the release notes for details of what’s new in
version 1.1.

The C# driver is available for download in source or binary form (.msi
installer or .zip file) from:

http://github.com/mongodb/mongo-csharp-driver
http://github.com/mongodb/mongo-csharp-driver/downloads

 

Pattern Matching Database Records with F#

A great article with code sample using new functionnal language from the microsoft .Net aka F# (inspired from CAML) has been published:  http://msdn.microsoft.com/en-us/magazine/gg598923.aspx

 

Ambar Ray, as an exercise, have implemented four matching algorithms using F# pattern matching and asynchronous programming features to quickly calculate the aggregate match score.

The four matching algorithms used in this example for attribute deduplication processes:

  • absolute match
  • partial match
  • Soundex
  • lookup match

It demonstrate how matching the result and scoring when appropriate.

Code sample is available here

Spring GemFire 1.0.0 Released for Java and .NET

Spring GemFire (for short SGF) brings the Spring concepts and programming model to GemFire, SpringSource’s distributed data management platform. The release is available for both Java and .NET.

The features in 1.0.0.M1 include:

  • declarative dependency injection style configurations for the GemFire infrastructure (such as Cache, Region, Interest, etc)
  • exception translation to Spring’s portable DataAccess exception hierarchy
  • Template and callback support for easy native API access
  • transaction management support
  • Spring-backed wiring for GemFire managed objects
  • auto-generation of non-reflection based Instantiators

Note that some of these features are currently available only in the Java version.

Through SGF, Spring users should feel right at home when interacting with GemFire while developers familiar with GemFire will see the benefits and flexibility of the Spring container, its powerful AOP integration, and versatile service abstractions. But don’t take my word for it – download the project and take the sample application for a spin. It’s a console based ‘shell’ which allows for ad-hoc interaction with the data grid; one can start and stop nodes and see the information shared transparently between multiple clients

Original annoucement: http://www.springsource.org/node/3015

Windows world and NoSQL: where do we stand ?

While we probably all agree to define NoSQL has a massive trend, we may disagree to define microsoft windows as the largest computer platform …. But still, it may sounds like a discrepancy to find out so few NoSQL products available on the leading platform market: Microsoft Windows.

Quick tour, as of today, NoSQL solution available over the windows world:

  • Raven DB document oriented database,open source, especially designed for the .NET platform is the leading answer
  • Voldemort (written using the cross-platform language: Java), few info can be found here
  • MongoDB provide windows binaries
  • Cassandra using the following specific instruction
  • Keyspace provide  .NET client
  • Eloquera DB object oriented database which maintains an SQL and LINQ interfaces

Finally i have to mention F#, probably  the smartest move  by Microsoft, its a functional programming language inspired from Objective CAML