Have you ever thought about having a database that you can write your objects directly, and use SQL for retrieving them back?

Code:
// Open connection to the server.
using (DB db = new DB("server=localhost;options=none;"))
{
    // Open the database.
    db.OpenDatabase("Cinemas");
 
    // Create the object we would like to work with.
    Cinema cinema = new Cinema() {
           Location = "Sydney",
           OpenDates = new DateTime[] { new DateTime(2003, 12, 10), new DateTime(2003, 10, 3) }
    };
                   
    // And here is where the magic begins...
    // Store the object - no conversion required.
    db.Store(cinema);
    
    // Magic is not finished yet.
    // Get an object that matches the criteria.
    var movies = db.ExecuteQuery("SELECT Cinema WHERE ALL Movies.Studios.Titles CONTAINS '20th Century Fox'");
    
    // Magic still goes on...
    // Creating parameters
    Parameters param = db.CreateParameters();
    param["dt1"] = new DateTime(2006, 10, 1);
    param["dt2"] = new DateTime(2009, 09, 17);
 
    // And here we search for the values IN THE ARRAY!
    var result = db.ExecuteQuery("SELECT Cinema WHERE OpenDates BETWEEN @dt1 AND @dt2", param);
 
    // And here we do something good with the objects retrieved from the database.
    foreach (var cinema in result)
    {
        Console.WriteLine(cinema.ToString());
    }
}
This is real code running on Eloquera Database 2.0 (codename Woomera) - the web-oriented client/server object database for .NET. It is already available as a pre-release version on the website Welcome to Eloquera 2.0 (codename Woomera).

The upcoming version of Eloquera database has some mind-boggling features, and I would like to give a brief list of its main features.

* Storing any .NET object without implementing any interface or inheriting from a specially designed class.
* Queries based on SQL. Yep, good old SQL. And no SQL database is required.
* Returns the objects in their native form, as a single object or as an enumeration.
* Supports arrays in queries. Any arrays - simple, multidimensional, jagged, of simple or complex types. And there is more!
* Supports JOINs in queries. And even for arrays.
* Expressions and functions in queries. You can perform JOINs or sort your data on them.
* Flexible sorting - there are some really useful ones.
* Regular Expressions are your best friends! Regex support in queries.
* Indexes. Yep, you can index data for faster access. Both fields and properties.
* Bulk inserts and updates. You can insert tens of thousands objects in a second.
* Generic object support. And also in queries.
* Inheritance support in queries (SELECT ParentClass returns both ParentClass and ChildClass)
* Queries only upon certain type. (SELECT ONLY ParentClass returns only ParentClass, but not ChildClass)
* Restoring objects partially (you might need ForumTopic object, but don't need all TopicMessage, linked with it)
* Depth for queries.
* Client/server architecture.
* Parallel and independent query execution for multiple users.
* Windows authentication. Specify no user name and log on under your current account.
* Both Server and client are implemented in 32- and 64-bit architectures.
* Unique identifier for any object within a database - for stateless environments (hence ASP.NET)
* Different cultures support in queries (e.g., "where dates BETWEEN['en-US'] @d1 and @d2" - formats will be treated as US English, even with the current UK settings on the machine)
* Approximate matching with ALMOST keyword.



Have you seen an object database with SQL query support? With JOINs? And with arrays?

So, what do you need to get Eloquera Database 2.0 running on your machine and ready for your command?

First, download and install the Eloquera setup files from the website. You will be asked to fill up a short registration form, and you will receive an e-mail with the download links. You need to download the server for your platform (32- or 64-bit). The server includes also all client libraries.

Installation is straightforward, and takes just a few seconds. The setup will install the service called Eloquera Server 2.0.

Included with the Eloquera server is a folder containing examples in C#. These examples are quite concise but cover various topics on using Eloquera, like JOINs and queries on arrays.

Secondly, you need to connect to the database in your code. By default, only the members of the Administrators group can access the database server. As Eloquera uses integrated Windows authentication, you can add your own user or a group to the list of the permitted security entities.

To do that, open the Eloquera Server configuration file (it is usually located at "%ProgramFiles%\Eloquera\Eloquera Server" and it called Eloquera.config) with any suitable text editor (as Notepad).

Find the Server element, and change the value of the AllowUsers or AllowGroups attribute, adding your user or group to the list. The items in the list are separated by a semicolon. It is advised not to remove Administrators group from the list.

For development purposes it is good practice to add Users group to the list of allowed groups. After this your <Server> element in the configuration file will like this:

Code:
<code lang="xml">
   <Server ServerPort="43962" Trace="true" Secure="true" AllowUsers="" AllowGroups="Administrators;Users" />
</code>
Restart the service for the changes to take effect. You can easily perform this task using the command line and running the following commands:

Code:
net stop "Eloquera Server 2.0"
net start "Eloquera Server 2.0"
And now Eloquera is ready to run your queries.

Below I am going to give some brief examples of Eloquera DB queries. We will discuss all the features in the next articles about Eloquera Database. These examples are intended to show how easily you can start working with Eloquera.

We are going to use these two classes as a base for our demonstration:

Code:
public class School
{
   public Location Location { get; set; }

   public string Name { get; set; }
}

public class WorkPlace
{
   public Location Location { get; set; }

   public string Company { get; set; }

   public string Position { get; set; }
}
So, we have stored a bunch of objects of both types in the database, and now we want to run a JOIN query to get some of them back.

Code:
var queryResult = db.ExecuteQuery("SELECT sch, wp FROM School sch INNER JOIN WorkPlace wp ON ch.Location=wp.Location");
Consider we have stored multiple instances of the following class in our database:
Code:
 public class User
 {
   public Location CurrentLocation { get; set; }

   public string Name { get; set; }

   public DateTime BirthDate { get; set; }

   public User[] Friends { get; set; }

   public WorkPlace UserWorkPlace { get; set; }

   public string[] Emails { get; set; }
 }
So, to find all users who has registered using the specific e-mail addresses, we can run a simple query with parameters:
Code:
Parameters param = db.CreateParameters();
param.AddList("emails", new string[]{"john@gmail.com", "david@hotmail.com"});
 
var res = db.ExecuteQuery("SELECT User WHERE Emails CONTAINS @emails", param);
As I said, you can find fully working examples of the Eloquera applications by installing the Eloquera server on your development machine.


Please follow the links below for downloading Eloquera DB v2.0 (codename Woomera).



Pre-release site for Eloquera 2.0 codename Woomera.

URL: Welcome to Eloquera 2.0 (codename Woomera)

Forum: Forum

Documentation: Eloquera Tutorial