Category Archives: CodeProject

NoSql (It’s “Not only SQL” not “No to Sql”)

This is my first post on NoSql database technologies. There have been drastic changes in database technologies over the few years. Increase in user’s requests, high availability of applications, real time performance forced to think on different database technologies. We have traditional RDBMS, memory and NoSql databases available in market to suffice particular business needs. Here I’ll illustrate some of key aspects of NoSql databases like what is NoSql, why we need it, advantages and disadvantages of NoSql.

What is NoSql Movement?

It’s a different way of thinking in database technologies. It is unlike relational database management system where we have tables, procedures, functions, normalization concepts. NoSql databases are not built primarily on tables and don’t use sql for manipulation or querying database.

NoSql databases have specific purpose to achieve, that means NoSql database might not support all the features like in relational databases.

NoSql databases are based on CAP Theorem.

  • Consistency: Most of the applications or services attempt to provide strong consistent data. Interactions with applications/services are expected to behave in transactional manner ie. Operation should be atomic (succeed or failure entirely), uncommitted transactions should be isolated from each other and transaction once committed should be permanent.
  • Availability: Load on services /applications are increasing and eventually services should be highly available to users. Every request should be succeed.
  • Partition tolerant: Your services should provide some amount of fault tolerance in case of crash, failure or heavy load. It is important that in case of these circumstances your services should still perform as expected. Partition tolerant is one of desirable property of service. Services can serve request from multiple nodes

Why NoSql?

Since NoSql databases are using for specific purpose. They are normally using for huge data where performance matters. Relational database systems are hard to scale out in case of write operation. We can load balance database servers by replicating on multiple servers, in this case read operation can be load balance but write operation needs consistency across multiple servers. Writes can be scaled only by partitioning the data. This affects reads as distributed joins are usually slow and hard to implement. We can support increase in no. of users or requests by scaling up relational databases which means we need more hardware support, licensing, increase in costs etc.

Relational databases are not good option on heavy load which are doing read and write operations simultaneously like Facebook, Google, Amazon, Twitter etc.

A NoSQL implementation, on the other hand, can scale out, i.e. distribute the database load across more servers.

clip_image002

Source: Couchbase.com

Common characteristic in NoSql databases

· Aggregating (supported by column databases): Aggregation usage to calculate aggregated values like Count, Max, Avg, Min etc. Some of NoSql provides support for aggregation framework which have inbuilt aggregation of values. Approach in column databases is to store values in columns instead rows (de-normalized data). This kind of data mainly used in data analytics and business intelligence. Google’s BigTable and Apache’s Cassandra supports some feature of column databases.

· Relationships (support by graph databases): A graph database uses graph structures with nodes, edges and properties. Every element contains a direct pointer to adjacent element; in this case it doesn’t need to lookup indexes or scanning whole data. Graph databases are mostly use in relational or social data where elements are connected. Eg. Neo4j, BigData, OrientDB.

 

image

Source: wikipaedia

 

· Document based. Document databases are considered by many as the next logical step from simple key-/value-stores to slightly more complex and meaningful data structures as they at least allow encapsulating key-/value-pairs in documents. Eg. CouchDb, MongoDb.

Mapping of document based db vs relational db

 

Document Based Databases Relational databases
Collections Table
Document Row

 

· Key- Value Store: Values are stored as simply key-value pairs. Values only stored like blob object and doesn’t care about data content. Eg. Dynamo DB, LevelDB, RaptorDB.

· Databases Scale out: When the load increases on databases, database administrators were scaling up tradition databases by increasing hardware, buying bigger databases- instead of scale out i.e. distributing databases on multiple nodes /servers to balance load. Because of increase in transactions rates and availability requirements and availability of databases on cloud or virtual machine, scaling out is not economic pain in increasing cost anymore.

On the other hand, NoSql databases can scale out by distributing on multiple servers. NoSQL databases typically use clusters of cheap commodity servers to manage the exploding and transaction volumes.  The result is that the cost per gigabyte or transaction/second for NoSQL can be many times less than the cost for RDBMS, allowing you to store and process more data at a much lower price;

Now question here is why scaling out in RDBMS is hard to implement. Traditional databases support ACID properties that guarantee that database transactions are processed reliably. A transaction can have write operations for multiple records, so to keep consistency across multiple nodes is slow and complex process, because multiple servers would need to communicate back and forth to keep data integrity and synchronize transactions while preventing deadlock. On the other hand NoSql databases supports single record transaction and data is partitioned on multiple nodes to process transactions fast.

· Auto Sharding (Elasticity): NoSql databases support automatic data sharding (horizontal partitioning of data), where database breaks down into smaller chunks (called shard) and can be shared across distributed servers or cluster. This feature provides faster responses to transactions and data requests.

 

· Data Replication: Most of NoSql supports data-replication like relational databases to support same data-availability across distributed servers.

 

· No schema required (Flexible data model): Data can be inserted in a NoSQL DB without first defining a rigid database schema. The format of the data being inserted can be changed at any time, without application disruption. This provides greater application flexibility, which ultimately delivers significant business flexibility.

 

· Caching: Most of NoSql databases supports integrated caching to support low latency and high throughput. This behavior is contrast with traditional database management systems where it needs separate configuration or development to support.

Challenges of No-SQL

Till now we have seen significant advantages of NoSql over RDBMS, however there are many challenges to implement NoSql.

Maturity: Most of the NoSql databases are in open source or in pre-production stage. In this case it might be risk to adopt these databases on enterprise level. For small business or use case it might be better to consider. On the other hand RDBMS databases are matured, providing many features and having good documentations or resources.

Support: Most of RDBMS are not open source that means they come with commitment and assurance in case of failure. They are reliable products and properly tested. Most of NoSql databases are open source and not widely adopted by organizations. It is very hard to get effective support from open sources databases. Some of NoSql databases created by small startups for specific needs, not for global reach.

Tools: RDBMS databases have lot of tools to monitor databases, queries analyzing, optimizations, performance profiling, analytics and Business Intelligence. Objective of NoSql databases are to minimize use of admin tools which has not achieved fully yet, still there are certain things which need skills and tools to monitor database activities.

When to consider NoSql

Following are some of indicators you can consider while choosing NoSql database for your application:

· If your application needs high performance databases.

· Need less or zero administration of databases.

· You want flexible data model. Minor of major changes should not impact whole system.

· Application that needs less complex transactions.

· High availability.

· Not or less consideration on Business Intelligence and analytics.

References:

· http://nosql-database.org/

· http://www.couchbase.com

· www.mongodb.org

· http://en.wikipedia.org/wiki/Nosql

Enhanced by Zemanta

General tips: How to run Visual Studio as administrator always

Some times it is needed to run visual studio as administrator for system level activities like if you want to setup IIS virtual directory in your visual studio project, To setup IIS settings etc.

If you want to run visual studio as administrator once, you can right click devenv.exe and select “Run As Administrator”.

But sometimes there are requirement to run visual studio always as admin then you can set privilege level to administrator. Here are the steps:

Step 1 : Goto to executable of Visual studio IDE in “C:Program Files(x86)Microsoft Visual Studio 9.0Common7IDE”, Right click on devenv.exe -> Properties -> Compatibility-> And Select “Run as Administrator” check box.

You will also need to setup for visual studio launcher.

Step 2: Go to executable of Visual Studio Launcher on “C:Program Files (x86)Common Filesmicrosoft sharedMSEnvVsLauncher.exe” and follow same steps like step 1.

Implementation of FIX messages for Fix 5.0 sp2 and FIXT1.1 specification

 

This post will demonstrate how to connect with FIX5.0 server and FIXT1.1 specification and uses of QuickFix/n (native .net FIX engine).

Introduction

With this release of FIX protocol version 5.0, a new Transport Independence framework (TI) introduced which separates the FIX Session Protocol from the FIX Application Protocol. This gives freedom to send message across different messaging technologies like MSMQ, message bus etc.

Because of different versions of transport and application protocol, we will have to explicitly defines settings in config file.

TransportDataDictionary is used for defining transport protocol version eg. FIXT.1.1.xml

AppDataDictionary is used for defining data dictionary for FIX application protocol version eg. FIX50.xml

You can read more about FIXT1.1 and FIX 5.0 Sp2 specification on fixprotocol.org.

http://fixprotocol.org/specifications/FIXT.1.1

http://fixprotocol.org/specifications/FIX.5.0

 

QuickFix/N

To demonstrate implementation of FIX 5.0 sp2, I’ll use open source FIX engine for .net (QuickFix/N) which is one of open source engine in native .net code.  Code for quickfix.net is available on github and primarily contributed by Connamara System’s developers. These guys are doing commendable job.

 

Implementation

FixInitiator

This is client application which will connect with FIX server to send and receive FIX messages. I am demonstrating implementation of MarketDataRequest and its responses (MarketDataSnapshot & MarketDataIncrementalRefresh).

 

Start with Configuration

First we create configuration file for initiator.

[default]
PersistMessages=Y
ConnectionType=initiator
UseDataDictionary=Y

[SESSION]
ConnectionType=initiator
FileStorePath=store
FileLogPath=fixlog
BeginString=FIXT.1.1
DefaultApplVerID=FIX.5.0

TransportDataDictionary=FIXT.1.1.xml

AppDataDictionary=FIX50.xml
SenderCompID=ABC
TargetCompID=FIXSERVER
SocketConnectHost=127.0.0.1
SocketConnectPort=3500
HeartBtInt=20
ReconnectInterval=30
ResetOnLogon=Y
ResetOnLogout=Y
ResetOnDisconnect=Y

 

*Note- AppDataDictionary is for application protocol eg. FIX 5.0 and TransportDataDictionary is for transport protocol.

You can read more about configuration here.

Create Application Class

Before starting with implementation you would need to have quickFix.dll which is available of github  athttps://github.com/connamara/quickfixn

 

To connect with FIX session, you will have to implement QuickFix.Application interface.

public interface Application
{
void FromAdmin(Message message, SessionID sessionID);
void FromApp(Message message, SessionID sessionID);
void OnCreate(SessionID sessionID);
void OnLogon(SessionID sessionID);
void OnLogout(SessionID sessionID);
void ToAdmin(Message message, SessionID sessionID);
void ToApp(Message message, SessionID sessionId);
}

I create one class named FixClient50Sp2 which implements interface and inherit base class for message cracking and getting message events.

image

 

FIX Application Setup

 

Setting up Initiator

// FIX app settings and related
var settings = new SessionSettings(“C:\initiator.cfg”);

// FIX application setup
MessageStoreFactory storeFactory = new FileStoreFactory(settings);
LogFactory logFactory = new FileLogFactory(settings);
_client = new FixClient50Sp2(settings);

IInitiator initiator = new SocketInitiator(_client, storeFactory, settings, logFactory);
_client.Initiator = initiator;

 

* _client is instance of class FixClient50Sp2.

Starting Initiator

_client.Start();

 

Implementation of QuickFix.Application Interface methods

/// <summary>
/// every inbound admin level message will pass through this method,
/// such as heartbeats, logons, and logouts.
/// </summary>
/// <param name=”message”></param>
/// <param name=”sessionId”></param>
public void FromAdmin(Message message, SessionID sessionId)
{
Log(message.ToString());
}

/// <summary>
/// every inbound application level message will pass through this method,
/// such as orders, executions, secutiry definitions, and market data.
/// </summary>
/// <param name=”message”></param>
/// <param name=”sessionID”></param>
public void FromApp(Message message, SessionID sessionID)
{
Trace.WriteLine(“## FromApp: ” + message);

Crack(message, sessionID);
}

/// <summary>
/// this method is called whenever a new session is created.
/// </summary>
/// <param name=”sessionID”></param>
public void OnCreate(SessionID sessionID)
{
if (OnProgress != null)
Log(string.Format(“Session {0} created”, sessionID));
}

/// <summary>
/// notifies when a successful logon has completed.
/// </summary>
/// <param name=”sessionID”></param>
public void OnLogon(SessionID sessionID)
{
ActiveSessionId = sessionID;
Trace.WriteLine(String.Format(“==OnLogon: {0}==”, ActiveSessionId));

if (LogonEvent != null)
LogonEvent();
}

/// <summary>
/// notifies when a session is offline – either from
/// an exchange of logout messages or network connectivity loss.
/// </summary>
/// <param name=”sessionID”></param>
public void OnLogout(SessionID sessionID)
{
// not sure how ActiveSessionID could ever be null, but it happened.
string a = (ActiveSessionId == null) ? “null” : ActiveSessionId.ToString();
Trace.WriteLine(String.Format(“==OnLogout: {0}==”, a));

if (LogoutEvent != null)
LogoutEvent();
}

/// <summary>
/// all outbound admin level messages pass through this callback.
/// </summary>
/// <param name=”message”></param>
/// <param name=”sessionID”></param>
public void ToAdmin(Message message, SessionID sessionID)
{
Log(“To Admin : ” + message);
}

/// <summary>
/// all outbound application level messages pass through this callback before they are sent.
/// If a tag needs to be added to every outgoing message, this is a good place to do that.
/// </summary>
/// <param name=”message”></param>
/// <param name=”sessionId”></param>
public void ToApp(Message message, SessionID sessionId)
{
Log(“To App : ” + message);
}

 

 

Callback to Subscription

public void OnMessage(MarketDataIncrementalRefresh message, SessionID session)
{
var noMdEntries = message.NoMDEntries;
var listOfMdEntries = noMdEntries.getValue();
//message.GetGroup(1, noMdEntries);
var group = new MarketDataIncrementalRefresh.NoMDEntriesGroup();

Group gr = message.GetGroup(1, group);

string sym = message.MDReqID.getValue();

var price = new MarketPrice();

for (int i = 1; i <= listOfMdEntries; i++)
{
group = (MarketDataIncrementalRefresh.NoMDEntriesGroup)message.GetGroup(i, group);

price.Symbol = group.Symbol.getValue();

MDEntryType mdentrytype = group.MDEntryType;

if (mdentrytype.getValue() == ‘0’) //bid
{
decimal px = group.MDEntryPx.getValue();
price.Bid = px;
}
else if (mdentrytype.getValue() == ‘1’) //offer
{
decimal px = group.MDEntryPx.getValue();
price.Offer = px;
}

price.Date = Constants.AdjustedCurrentUTCDate.ToString(“yyyyMMdd”);
price.Time = group.MDEntryTime.ToString();
}

if (OnMarketDataIncrementalRefresh != null)
{
OnMarketDataIncrementalRefresh(price);
}
}

 

Code can be found at github.

 

https://github.com/neerajkaushik123/Fix50Sp2SampleApp.git