For those unfamiliar with CouchDB, it is a free and open source document-oriented database written in the Erlang programming language. It is designed for local replication and to scale vertically along a wide range of devices. Provides a RESTful JSON API than can be accessed from any environment that allows HTTP requests.

ExtJS is a cross-browser JavaScript library for building rich internet applications, using techniques such as AJAX, DHTML and DOM scripting.

I wanted to communicate to my CouchDB backend from HTML/Javascript frontend using Ext.data.Store (stores load data via a Proxy, and also provide functions for sorting, filtering and querying the model instances contained within it.) … one of the coolest features I love about ExtJs.

Since CouchDB runs on port 5984 (not on port 80) and I was IIS 7 as a webserver (runs on port 80) and because of the Same Origin Policy, browsers reject requests to load a document or script unless the protocol, port and host are identical to the source of the current page. Therefore I was unable to talk with CouchDB database. There is one approach using Ext.data.ScriptTagProxy(used to load data from a domain other than the one your application is running on) but I didn’t like this approach because it messes up my code.

I wanted to use IIS web server as a reverse-proxy server that receives web requests and forwards them to CouchDB for processing. Whenever I’d issue a GET request for “/couchdb/[database]/_design/products/_view/list” reverse-proxy server receives the request and forwards to CouchDB for processing … the re-written url would look like this: “http://localhost:5984/[database]/_design/products/_view/list”

The following figure illustrates a typical configuration for a reverse-proxy scenario:

Application Request Routing and URL Rewrite to the rescue

To implement the reverse-proxy server you need to install:

1. URL Rewrite  Module
2. Application Request Routing

Then open IIS Manager and:

1. Navigate to “Application Request Routing” feature
   
   

2. Check the “Enable Proxy”
   
   
3. Under system.webServer section in web.config add the following lines:

   <system.webServer>		
           <rewrite>
               <rules>
                   <rule name="Reverse Proxy to CouchDB" stopProcessing="true">
                       <match url="^couchdb/(.*)" />
                       <action type="Rewrite" url="http://localhost:5984/{R:1}" />
                   </rule>
               </rules>
           </rewrite>
   </system.webServer>

So as you can see, we have added a new rule which matches all web requests that begin with couchdb and we rewrite them to http://localhost:5984/[whatever comes after couchdb].

By using IIS as reverse proxy for CouchDB, http://localhost/couchdb is equivalent to http://localhost:5984.

Hope this helps and saves you a couple of hours to figure it out.

I’m not sure whether you can achieve this without creating a data context wrapper, because for each query you have to combine two logical expressions, the expression that comes from repository and p => p.Active == true.

I thought it was worth sharing with you this.

Assuming that we have the following State entity:

This is how I would d solve this … I would simply have a generic class which is responsible for building expressions and issuing queries to the database.

 
    /// <summary>
    /// A generic class that executes queries againts a data context
    /// </summary>
    /// <typeparam name="Context">The Database context</typeparam>
    /// <typeparam name="T">The entity</typeparam>
    public class DataContextWrapper<Context> where Context : DataContext, new()
    {
        Context DataContext;
 
 
        /// <summary>
        /// The connection string
        /// </summary>
        string ConnectionString
        {
            get
            {
                //usually this comes from configuration file (web.config / app.config)
                return "[ConnectionString]";
            }
        }
 
        /// <summary>
        /// Class constructor that instantiates a new DataContext object and associates the connection string
        /// </summary>
        public DataContextWrapper()
        {
            DataContext = new Context();
            DataContext.Connection.ConnectionString = ConnectionString;
        }
 
 
        protected virtual IEnumerable<T> GetItems<T>([Optional] Expression<Func<T, bool>> query) where T : class, new()
        {
            //get the entity type
            Type entity = typeof(T);
 
            //get all properties
            PropertyInfo[] properties = entity.GetProperties();
 
            Expression<Func<T, bool>> isRowActive = null;
            //we are interested in entities that have Active property ==> to distinguish active rows
            PropertyInfo property = entity.GetProperties().Where(prop => prop.Name == "Active").SingleOrDefault();
 
            //if the entity has the property
            if (property != null)
            {
                //Create a ParameterExpression
                //if the query is specified then we need to use a single ParameterExpression for the whole final expression
                ParameterExpression para = (query == null) ? Expression.Parameter(entity, property.Name) : query.Parameters[0];
 
                var len = Expression.PropertyOrField(para, property.Name);
                var body = Expression.Equal(len, Expression.Constant(true));
                isRowActive = Expression.Lambda<Func<T, bool>>(body, para);
            }
 
            if (query != null)
            {
                //combine two expressions
                var combined = Expression.AndAlso(isRowActive.Body, query.Body);
                var lambda = Expression.Lambda<Func<T, bool>>(combined, query.Parameters[0]);
                return DataContext.GetTable<T>().Where(lambda);
            }
            else if (isRowActive != null)
            {
                return DataContext.GetTable<T>().Where(isRowActive);
            }
            else
            {
                return DataContext.GetTable<T>();
            }
 
        }
 
    }

As you can see, we have a method IEnumerable GetItems([Optional] Expression> query) which has an optional argument where you can pass lambda expressions.

And for every query, if the entity has the Active member, we append p => p.Active == true to the query. In this way we only specify it once, and we make sure that every method on our repositories, return only active records.

This is how a simple repository would look like:

/// <summary>
/// States Repository
/// </summary>
public class StatesRepository : DataContextWrapper<DEMODataContext>
{
    /// <summary>
    /// Get all active states
    /// </summary>
    /// <returns>All active states</returns>
    public IEnumerable<State> GetStates()
    {
        return base.GetItems<State>();
    }
 
    /// <summary>
    /// Get all active states
    /// </summary>
    /// <param name="pattern">State pattern</param>
    /// <returns>All active states tha contain the given pattern</returns>
    public IEnumerable<State> GetStates(string pattern)
    {
        return base.GetItems<State>(s=>s.Description.Contains(pattern));
    }
 
}

The usage:

StatesRepository repo = new StatesRepository();
var activeStates = repo.GetStates();

And

var filtered = repo.GetStates("Al");

Hope this helps.

So here we go …

What is MEF?

Managed Extensibility Framework (MEF) is a new library in the .NET Framework 4 and in Silverlight 4 that simplifies the design of composable systems that can be extended by third parties after they have been deployed. It is all about enabling dynamic composition of components across your application, adding/removing classes/components from your running system dynamically without any changes to the running code.

MEF is most useful with dynamic dependencies known only at run-time and it is optimized for discovering unknown parts of the system. It is built for open systems – scenarios in which the complete set of components that make up an application is defined at run-time.

You can read more about MEF here:

• Managed Extensibility Framework Overview
• MEF on CodePlex
• Building Composable Apps in .NET 4 with the Managed Extensibility Framework
• Glenn Block (the former PM of MEF team and now PM on the WCF team working on Microsoft’s future HTTP and REST stack).
• Nicholas Blumhardt – the founder of Autofac
• Hamilton Verissimo aka hammett –  founder of the Castle Project
• MEF Samples
• Extending NerdDinner: Adding MEF and plugins to ASP.NET MVC - by Scott Hanselman

Each application that I’ve built, whether it’s web or desktop app., it is consisted of one or more components each responsible for doing some particular job, manage products, generate reports etc. Before MEF, I would simply reference the assembly and call it directly from the code.  This is what I’ve always been doing and probably all of you. But as much as you try, yes you can make your code reusable and all that stuff, but you cannot avoid dependencies. Eventually, you are probably going to deploy more assemblies that you are paid for.

And by introducing dependencies you end up with:

• tight coupling of software components
• software becomes hard to maintain
• difficult to isolate when testing

And most importantly, you cannot add new components without modifying the existing source code, because you may not have access to the source code for the components, they might have been developed by third party companies / developers.

But with MEF you can avoid that, because it  provides a way to discover software components implicitly, via composition. (more on this later.)

Consider for example Visual Studio 2010, everyone can develop extensions and make them available for download so other developers can install them in their development environment, but you don’t have access in the source code of VS. But you do it based on some shared contracts and some pre-defined conventions. In this way, VS knows how to load them and make them available to you.

Where is MEF used?

MEF is used by Microsoft internally … it is not some patterns & practices given to you as an example on how to build applications. They actually use this and have things that rely on MEF. In the following post you can see the applications of MEF - http://codebetter.com/glennblock/2010/06/03/mef-has-shipped.

I’ve followed the development of MEF on codeplex since MEF Preview 5 and I am very glad to say that it has truly matured since then. I can only say that it has seriously changed my thinking on solving complex problems.

In future I’m planning to write a series of posts where I’m going to cover the main concepts of MEF and show you how you can build extensible web applications using MEF and Asp.Net MVC.

So stay tuned!

http://www.sqlservercentral.com/blogs/dave_ballantynes_blog/archive/2010/11/10/denali-paging_1320_is-it-win_2F00_win-_3F00_.aspx

While the new ORDER BY Clause definition here:

http://msdn.microsoft.com/en-us/library/ms188385(SQL.110).aspx

For other new features in Denali please see here:

http://msdn.microsoft.com/en-us/library/bb500435(v=SQL.110).aspx

Already starting to love it.

It has been a while since my last post!

I am writing this to inform you that I will be attending Qt Developer Days 2010 in Munich, if you happen to be there during the days, feel free to ping me for a conversation.



What i wanted to achieve is to get three most sold pizzas and three most active clients. Although the result is easier that i supposed, as i said, i tended to get them as i think from the T-SQL world. My first approach was like this:

var topPizzas = from pizza in dataContext.OrderDetails
 
.GroupBy(p => p.PizzaTypeID)
 
select new {pizza.Key, Total = pizza.Sum(p => p.Quantity)};
 
var top3Pizzas = topPizzas.Take(3);
 
var topCustomers = from customer in dataContext.Orders
 
.GroupBy(p => p.CustomerID)
 
select new {customer.Key, Total = customer.Count()};
 
var top3Customers = topCustomers.Take(3);

This way we get the right result but we get just the id of the pizza and the sum of quantity orders it was ordered. Whenever we try to project to a pizza type we will hit the wall on full speed asking our selves where is the problem, it “MUST” work this way.

But this time must come, “Wait a minute, what do i want?” and yeah the answer is top pizzas and customers and probably not some order… thing and the following query really must work:

var topPizzas = from pizza in dataContext.PizzaTypes
 
orderby pizza.OrderDetails.Sum(p => p.Quantity) descending
 
select pizza;
 
var top3Pizzas = topPizzas.Take(3);
 
var topCustomers = from customer in dataContext.Customers
 
orderby customer.Orders.Count() descending
 
select customer;
 
var top3Customers = topCustomers.Take(3);
 
And even a shorter version with lambda expressions looks like this:
 
var topPizzas = dataContext.PizzaTypes
 
.OrderByDescending(pizza => pizza.OrderDetails.Sum(p => p.Quantity));
 
var top3Pizzas = topPizzas.Take(3);
 
var topCustomers = dataContext.PizzaTypes
 
.OrderByDescending(pizza => pizza.OrderDetails.Sum(p => p.Quantity));
 
var top3Customers = topCustomers.Take(3);

This is probably just a first step to forgetting T-SQL queries (perhaps not DDL ) and looking ahead! Don’t hesitate to ask yourself what you want, the answer is always inside your self… hahaha and no i’m not from social sciences, just joking.

In the first glance this text might look like gibberish, however to some people it might resemble to something they have seen or read previously.

This one as well:

What we are seeing in the previous two examples is automatically generated text using Markov Chains. The first one resembles the style of a famous Albanian poet: Gjergj Fishta.  The other one resembles The Illiad by Homer.

I needed to benchmark two databases: MySql and MongoDB. However, since I did not have any data (that would resemble human comments) I had to find a way to automatically generate them. That is why I choose to write an application that would automatically generate text.

One can say that automatically generating text is simple, just taking random words from the dictionary and you are done. However, this approach has one big problem: the text would not look natural at all. This is because we do not take into consideration the statistics of a language. In a language, each word is not followed randomly by another word; e.g., the word “hello” in the English language is more likely to be followed by the word “world” than by the word “hi”.

Markov Chain is a process of generating a finite state sequence of events (in our case words), in which you can transfer from each state to another based on some probabilistic model. E.g., suppose your current state is “hello”. From here you can jump to another state like: “world” or “home” because there is a probability that these two words proceed the word “hello”.

Building a Markov Model is fairly simple:

First you will need a text file, from which you will build the model.

For each word from that text file, create e k-level list of words proceeding it. k is a fixed number of words that proceed each word. The higher k is, phrases will make more sense. After you are done with all the words you will have a table, with each row representing a starting word, followed by k-other words.

Let’s suppose our text is the Wikipedia Article for Markov Chains (http://en.wikipedia.org/wiki/Markov_chain).

If k=2 then our table would have the following structure:

If k=3 then we would have the following table:

One can continue with the same pattern for k=4, 5 … N.

Since now have our model, we can generate text from it:

1. Pick a random word (from our list of words). Let this word be the first word of your automatically generated text.

2. Randomly select one of the elements from our table that starts with the word that we picked.

3. Append all subsequent words from the list to the generated text.

4. Repeat from step 2, for the last word on your list.

My approach is a word level Markov Chain generator. One can change the same algorithm to generate character level chains, which also generate interesting text patterns.

You can download the entire solution written in C#:

Markov Chain Source
MarkovTextGenerator.rar
Version: 1.0

Author:	Visar Shehu
Date:	February 6, 2012

38.8 KiB
796 Downloads
Details...

The solution is simple (but saved a lot of time for me):

In SQL Server Management Studio select
Tools -> Options -> Designers and uncheck “Prevent saving changes that require table re-creation”

Simple as that

LINQ (Language Integrated Query) paraqet nje teknologji te re te Microsoft qe perkrahet nga .NET 3.5 e siper, e cila mundohet te zgjedhe (ose lehtesoje) menyren e manipulimit me te dhena si databaza, XML ose te kolekcione rekordesh ne memorje (lista, vargje …).

ORM

Para se te flas per LINQ, ne dy pjeset e para te kesaj serie do paraqes nje hyrje te shkurter per Object Relational Mapping (ORM). ORM paraqet nje qasje (ose metodologji) programimi ku zhvilluesi mundohet qe te paraqese ne forme abstrakte objektet nga nje databaze (tabelat, lidhjet etj.) ne nje forme me te afert me konceptet e njohura nga modeli i orientuar ne objekte (OO Model).

Ekzistojne disa implementime komerciale dhe open source per ORM automatik. Ne kete post manualisht do te krijojme ORM, me specifikisht ate qe njihet Reverse Mapping (krijimi i klasave nga tabelat). Ky post nuk ka per qellim te pershkruje te gjithe specifikat e ORM, por vetem te parashtroje problemet e mundshme me te cilat do te ballafaqohej nje perdorues gjate krijimit te ORM.

Ne esence nje tabele ne databazen tone paraqet kolekcion reshtash dhe kolonash. Cdo resht mund te trajtohet si objekt, ndersa cdo kolone mund te trajtohet si atribut / karakteristike e atij objekti. Menjehere verehet nje ngjashmeri ndermjet tabelave dhe klasave. Cdo klase pershkruan nje objekt, objektet paraqesin instance te nje klase. Cdo objekt definohet nga karakteristikat e tij (qe implementohen me variabla) dhe sjelljeve (behaviors) te tij (qe implementohen me metoda).

Te marim nje shembull:

Me SQL kjo tabele do krijohej ne kete menyre:

CREATE TABLE Perdoruesit
(
ID uniqueidentifier,
Emri nvarchar(10) NULL,
Mbiemri nvarchar(10) NULL,
EmriPerdoruesit nvarchar(20) NOT NULL,
Fjalekalimi nvarchar (50) NOT NULL,
PRIMARY KEY (ID)
)

Nga skema relacionale e kesaj tabele, shihet qarte se ne mund te definojme nje klase:

class Perdoruesi
{
public Guid ID { get; set; }
public String Emri { get; set; }
public String Mbiemri { get; set; }
public String EmriPerdoruesit { get; set; }
public String Fjalekalimi { get; set; }
}

E qarte qe tani ne mund te krijojme instanca te kesaj klase:

Perdoruesi p = new Perdoruesi();
p.ID = Guid.NewID();
p.Emri = "Visar";
p.Mbiemri = "Shehu";
p.EmriPerdoruesit = "vshehu";
p.Fjalekalimi = "sekret";

Nga kjo mund edhe te krijojme kolekcione te tipit Perdorues:

List<Perdoruesit> lista = new List<Perdoruesit>();
lista.Add(p);

Pastaj dhe te manipulojme me to, psh ti listojme vetem ato perdorues Emri i te cileve fillon me shkronjen “A”:

foreach (Perdoruesi tmpP in lista)     
{          
if (tmpP.Emri.StartsWith("A"))          
{               
Response.Write(tmpP.Emri));          
}      
}

Sidoqofte, deri tani ne kemi vetem nje kopje te skemes relacionale ne memorje. Cdo objekt qe do ta krijojme do te shkaterohet automatikisht dhe me te edhe te dhenat per ate objekt ose kolekcion. Qe te kemi nje aplikacion funksional ne duhet te implementojme CRUD operacionet (Create, Read, Update, Delete). Te gjithe keto do ti implementoj si metoda ne klasen Perdorues (qasje e cila eshte diskutabile, mirepo problemet me kete qasje do ti adresoj ne postin e ardhshem).

Create

Ky eshte edhe operacioni i pare qe do te deshim ta implementojme per objektin tone. Ideja eshte e thjeshte: te kemi nje mundesi qe objektin e krijuar ne memorje, ta regjistrojme si rekord ne databaze. Ne esence duam qe objekti jone te kete nje sjellje (behavior) qe do te ruaje gjendjen e ketij objekti. Sjelljet ne OO terminologjine implementohen me ane te metodave. Per rastin tone do te krijojme nje metode Save() qe do te na mundesoje kete. Klasa Perdoruesi tani do te kete kete forme:

class Perdoruesi
    {
        public Guid ID { get; set; }
        public String Emri { get; set; }
        public String Mbiemri { get; set; }
        public String EmriPerdoruesit { get; set; }
        public String Fjalekalimi { get; set; }
 
        public void Save()
        {
            String sql = "INSERT INTO Perdoruesit(ID, Emri, Mbiemri, EmriPerdoruesit, Fjalekalimi) VALUES (@ID, @Emri, @Mbiemri, @EmriPerdoruesit, @Fjalekalimi)";
            SqlConnection con = new SqlConnection();
            SqlCommand cmd = new SqlCommand();
            cmd.CommandText = sql;
 
            //Shtojme parametrat e nevojshem
            cmd.Parameters.Add("@ID", this.ID);
            cmd.Parameters.Add("@Emri", this.Emri);
            cmd.Parameters.Add("@Mbiemri", this.Mbiemri);
            cmd.Parameters.Add("@EmriPerdoruesit", this.EmriPerdoruesit);
            cmd.Parameters.Add("@Fjalekalimi", this.Fjalekalimi);
 
            //Hapet konekcioni dhe ekzekutojme komanden
            con.ConnectionString = "Definojme connection string ketu";
            con.Open();
            cmd.ExecuteNonQuery();
            con.Close();
        }
 
    }

Shfrytezuesit e kesaj librarie do te shohin vetem kete Interface te klases tone:

Dhe kur nje shfrytezues do ta shfrytezoje kete klase, ai do te jete i sigurt se sapo ta perdore metoden Save() ne bazen e te dhenave do te regjistrohet nje perdorues i ri:

Perdoruesi p = new Perdoruesi();
p.ID = Guid.NewID();
p.Emri = "Visar";
p.Mbiemri = "Shehu";
p.EmriPerdoruesit = "vshehu";
p.Fjalekalimi = "sekret";
p.Save()

Ngjashem mund te implementohet edhe metoda Delete(). Ne postin e ardhshem do te flas se si mund te implementohen metodat tjera per leximin e nje ose me teper rekordeve, qe me vone te kalojme ne perdorimin e ndonje ORM te gatshem.

But when trying to change the collation I came across the following error:

The database could not be exclusively locked to perform the operation.

Apparently you cannot change the database collation if the accessibility of the database is set to MULTI_USER (which is by default).

Therefore if you want to change the database collation, you must do the following:

• Set the restrict access of the database to  SINGLE_USER (note the you might kill all the active sessions)
• Change the collation of database to whatever you want it, in my case SQL_Latin1_General_CP1251_CS_AS
• And switch back the restrict access of the database to MULTI_USER

You can accomplish this either by executing the following t-sql in you sql management studio:

ALTER DATABASE [database_name] SET SINGLE_USER WITH ROLLBACK IMMEDIATE
ALTER DATABASE [database_name] COLLATE [desired collation]
ALTER DATABASE [database_name] SET MULTI_USER

or from SQL Management Studio by choosing the database properties:

Sometimes the simplest issues can cause you a real headache.