The license we have chosen is the permissive MIT license – we hope that by choosing this license we can encourage developers to use BrightstarDB in their projects regardless of whether they are developing open or closed-source software.

So what’s next ?

Over the next few days there will be some tweaks and changes to the site and some tidying up of the code to enable everything to be built with a basic tool-kit of Visual Studio 2012 and some free / open-source tools. The main task facing us is the migration of documentation from the commercial Help and Manual product to some other form (right now we are thinking probably DocBook XML as HTML output for the site will be our primary concern); and some updates to the installer build to remove dependencies on the commercial obfuscator/IL merge tool we were using.

We are hosting the source on GitHub at https://github.com/BrightstarDB/BrightstarDB and we will use CodePlex (http://brightstardb.codeplex.com/) to host the “official” project binaries as and when they become available as well as using NuGet to distribute the core libraries as we have been doing with the closed-source offering up to now.

Want to get involved ?

Great! To be honest right now we are focussing just on getting the distribution updated and a new release out under the MIT license which can be built without using any of the commercial tools we have used in the past (with the exception of VS2012 for now). However, we would welcome potential contributors to come forwards, and of course you can always fork us any time you like on GitHub!

Onwards and upwards!

First, open Visual Studio and create a new console application; then add a reference to the BrightstarDB DLL that is found in the installation directory (under BrightstarDB/SDK/NET40). Make sure that the Target framework is not set to a client profile. Register your license as outlined in the documentation “Licensing For Embedded Applications”

Entities are Interfaces

Each entity in our system is created using an Interface. Right click the project and select Add > New Item and select the Interface filetype; give it the name IPerson. Repeat this step and create another interface named ICompany.

To turn these interfaces into BrightstarDB entities, we add the Entity attribute to the interface. Every BrightstarDB entity must have a read-only Id property that is of type String. After both interfaces have the Entity attribute and the Id property, any number of properties can then be added to the entities, as shown below:
 

Relationships between Entities

To link the Person and Company entities, simply add a property to each of the entities showing the relationship between the two.
The second property is given the InverseProperty attribute, so that it is marked as describing the other end of the same relationship.

BrightstarDB Context file

Right click on the project and select Add > New Item > Brightstar Entity Context (in Data category). This adds a Text Transform file which picks up on the interfaces with the Entity attribute and builds a BrightstarEntityContext from the code. If you make any changes to the code of the interfaces, you can rebuild the BrightstarDB Context at any time by right clicking on the context file and selecting “Run Custom Tool”.

Creating and updating entities

Open the Program.cs file and add the following code:
This creates 3 Person entities and adds properties to them. It also shows the creation of a Company entity and links that entity to two of the Person entities. Run the program (F5) to create the

Reading entities

To quickly view the data produced by this code, you can open Polaris and do a quick query. To access entities problematically you can use LINQ similar to the example below:

More information

For more detailed explanations of how to develop with BrightstarDB, read Developing with BrightstarDB. There are also samples in the BrightstarDB installer, and explanations for each sample within the BrightstarDB documentation. As always you can use the BrightstarDB Community Pages for any questions or feedback.

RDF Format

To understand SPQARL, first it is best to learn more about the format of RDF. RDF stores data in the forms of triples. Each triple consists of a subject, a predicate and an object.

Subject
The subject is the address of the resource being described.
Predicate
The predicate describes the relationship between the subject and the object
Object
The object is the value of the property, this can be either a literal value or the address of another resource

It is sometimes easier to describe these triples as Resource -> Property -> Value

For example, if we were to describe details of a company* in RDF form, it might look similar to the following:

*data taken from the business.data.gov.uk dataset on datahub.io, click “view raw” for a cleaner view.

Simple SPARQL Queries

The best way to demonstrate SPARQL queries is to dive right in with some examples. We will be using Polaris tool that installs with BrightstarDB, and the business.data.gov.uk dataset used in the previous post “First steps with Polaris“.

1. Select all businesses ordered by town

select ?business ?town where {?business <http://research.data.gov.uk/def/project/town> ?town } order by ?town

This returns 275 rows of data, consisting of two columns, the first being “business” (the resource ID for the business) and the second being “town”. The results are ordered by the town column, starting with Abbotsley and ending with York.

2. Select all businesses in Manchester

select ?business where {?business <http://research.data.gov.uk/def/project/town> "Manchester" }

This query returns 7 rows, consisting of a single column of resource IDs. To return more information about the businesses, we can extend the query to include extra properties and their values.

3. Select all businesses in Manchester and any other information about them.

select * where {?business <http://research.data.gov.uk/def/project/town> "Manchester" . ?business ?property ?value }

This returns far more information, in total 150 rows of data are returned that describe the 7 companies returned from the previous query.

This blog post is only designed to give a brief introduction into SPARQL, and so for a more in depth look into the language there are many different resources available on the web.

SPARQL resources online

• Full SPARQL 1.1 Documentation at the W3C
• Querying semantic data tutorial*
• SPARQL By Example*

*written for SPARQL 1.0 but still a thorough introduction to the language

When opening Polaris for the first time, you will be given a prompt to create a connection:

Without a connection set up you will not be able to create any stores, so click “Yes” to open a new Connection Properties dialog box:

The recommended setting is to connect to a BrightstarDB server; selecting “HTTP” from the Connection Type field will auto-fill the other fields with the default settings for a local BrightstarDB service. Add a name for the connection and click “OK”.

Note: the BrightstarDB installation sets up the BrightstarDB service at the localhost:8090 HTTP endpoint. You must have the IIS feature enabled on your machine for this endpoint to have been created successfully. If after creating a connection, Polaris reports it is not able to connect, check the installation pre-requisites and that the service is has started successfully.

Creating a store

Creating a new store within Polaris simply consists of right-clicking on the connection name, and selecting “New Store”

Adding data

There are a number of different ways to add data to a store, which you choose will depend entirely on your project. For the purpose of this blog post we will find an existing dataset on the web, and import it directly into our new BrightstarDB store.

I have chosen a widely available dataset of business-related data from data.gov.uk, which can be dowloaded from the datahub.io. Right click on the store, and select New > Import Job Import the dataset into your newly created store (for more information, see the “Importing Data” section of Using Polaris)

Query the data

Querying in BrightstarDB is done with SPARQL. Detailing SPARQL queries is outside the scope of this blog post, but the most basic one would be a “select all”:

SELECT * WHERE {?subject ?predicate ?object}

The next post will talk more about SPARQL querying of data, or use the BrightstarDB Community Pages for any questions or feedback.

Licensee: Enter the email address that you registered on the BrightstarDB website.

License Key: Login to your account at http://brightstardb.com/customers to retrieve or request license keys.

Click here for more information about the BrightstarDB Licensing Options, or use the BrightstarDB Community Pages for any questions or feedback.

The Mobile and Embedded editions contain just the core BrightstarDB DLLs that are needed to build applications on the phone or on the desktop. The Server edition contains all the DLLs and services to run BrightstarDB as a service. Finally, the Enterprise edition contains everything in Server but also contains the BrightstarDB SDShare Server. The SDShare server provides the ability to expose existing data systems as RDF that can be consumed into BrightstarDB instances.

The other major change with this release is the introduction of license protection. All BrightstarDB versions now require a valid license. Trial licenses can be acquired from the website.

Check out the what’s new section of the documentation for details of technical changes in 1.2.

This release has two main features. Firstly, the Entity Framework now supports arbitrary levels of interface inheritance in your entity interfaces. This makes it much easier to create complex data models that using either straight-forward single inheritance or a more mix-in strategy of multiple inheritance. Secondly we are pleased to have added support for Visual Studio 2012 integration to add the item templates for the BrightstarDB entity context and entity definitions. Currently we only target Visual Studio 2012 Professional or above. If you are using one of the Express versions of Visual Studio 2012 the installer will not be able to add the item templates – we hope to have this issue addressed in a future release.

At the same time we have updated the BrightstarDB packages on NuGet. We would like to thank Ken LeFebvre who initially created the BrightstarDB package back when we were still in beta, both for showing us what a good idea it is and also for allowing us to take over the management of the package. We now have two packages on NuGet – if you want to build an application using our Entity Framework, then install the BrightstarDB package to get the main BrightstarDB DLL and the entity context text template; if you want to code against the RDF API, Data Objects API or Dynamics objects API, then you can use the BrightstarDBLibs package to install just the BrighstarDB DLL.

To get hold of the full installer, head over to the Download page.

Thank you to everyone who has helped us get to this point. We believe that BrightstarDB is a really unique and powerful offering on the .NET platform and are excited to see the many different ways people are using it.

Commercial licenses can now be purchased via our secure payments page, see the download page for more information.

Alongside the 1.0 release of the on-premise version is the beta version of the Azure service offering. If you would like to be considered for our beta programme then please contact us contact@brightstardb.com

Note: We made only a few minor bug fixes from the release candidate and no major breaking changes.

Major Feature

As well as the append only store BrightstarDB now supports a store format we call ‘rewrite’. This is intended to be used on phone devices or in applications that have limited disk space. Stores using the rewrite version use much less disk space.

IMPORTANT NOTE

While there are no API changes, the release candidate has a major breaking change in that all stores created with previous versions are not compatible. We needed to change the store format in order to provide the rewrite store capability and to improve transaction processing capabilities and memory footprint for large stores. We felt the improvements in stability and performance were worth changing the store format and apologise for any inconvenience this may cause.

To upgrade existing stores where the data cannot be reimported or recreated export the RDF via Polaris BEFORE UPGRADING. Install the new version of BrightstarDB and re-import the RDF.

We are commited that, bar any critical bug fixes, there will be no further breaking changes to the store format for the 1.0 release and any subsequent releases will include data store migration utilities.

Thank you to all the people who have been using BrightstarDB and providing valuable feedback!

Download the BrightstarDB 1.0 Release Candidate.

BrightstarDB is a NoSQL triple-store database. This means its schema-less and thus an ideal way to store the state of dynamic objects. More specifically BrightstarDB offers a data context dedicated to working with dynamic objects.

To see how the BrightstarDB dynamic support can be used to build a data driven system we have published a complete project on github. In this post we’ll walk through the key aspects.

We start by reviewing the basic support for dynamic persistence in BrightstarDB.

The aim of this sample project is to create a dynamic data driven system. While most usages of dynamic are ad-hoc we are building a complete system and want to introduce some structure while only using dynamic objects.

The main thing we want to do is introduce the idea of ‘types’. This may sound a little strange but these are not static types in the .NET sense, they are more like prototypes or type descriptors. Each type will also be a dynamic object and it will contain a known property that will list the names of the keys that apply to instances of this type. We say ‘apply to’ as there is no strict enforcement that instances shall have these properties.

The types are used for grouping and finding instances of the right type and also for dynamically introspecting instances. The other well known property we will use is one that connects instances to their type. To start, each dynamic instance will be connected to just one type, but as this is all dynamic and all ‘just’ data it is possible that an instance could have multiple types. The pattern we are describing here is a classic grounding, or bootstrapping approach to creating layers of structure in a generic model. We use just a couple of well known, or grounding properties, from which we can build structure.

It is important to note that this dynamic system is just one kind. The great thing about dynamic objects is that they let the developer build different kinds of models and meta-models to suit the problem at hand.

Our dynamic system will offer the following interface. The comments on each method provide an outline of what capabilities it provides:

The following implementation of the interface shows how we can use the BrightstarDB support for dynamic to implement the methods of our typed dynamic system:

These tests show how to use the DynamicSystem service object we have created.

Use cases for a dynamic persistent system

Now that we can easily persist dynamic objects what can we use it for? The generic use case is one where users or administrators or other parts of the system code have a need to create types at runtime. Here are two specific examples:

The first example is a content management system. Administrators are allowed to define content types when the system is running. For each content type they can define the properties that an instance should have. A UI generator can introspect the dynamic types to see which properties to show and instances of each type would of course be dynamic objects.

The second use case is a system component that receives event data from multiple sources. Each source provides consistent data but in a structure that is different from other sources. Some elements of the event data are consistent, such as when it occurred. But all other data is dynamic. The event aggregator implemented using dynamics would be able to create a new dynamic type when it first encouters a new event type and then create dynamic instances to represent the event data.

In this post we have used the basic dynamic persistence capabilities in BrightstarDB to create a complete persistent dynamic system.