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:	September 9, 2010

38.8 KiB
133 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.

I proudly announce that we are having a KDE SC 4.4 Release Party in Prishtina, it will be held on 9th of February at 18:00 o’clock at IDI (Information Development Initiative) Academy offices, here is the map to the location and here is the link to the KDE.org release party list, you are free to join us.

Let’s celebrate together this KDE release.

Each day we grow as developers and also in 2010 we’ll be here to continue to share our experience on solving complex programming problems and inspirational highlights.

Happy New Year 2010

A big thank you for all your support – we could not do it without you (our readers).

I am a proud Qt Developer now. Yesterday I earned the title Nokia Certified Qt Developer.

Back at my studies (Computer Sciences in SEE-University) I had the chance to read C# 3.0 Design Patterns by Judith Bishop, a great book which covers the full set of 23 patterns that were originally proposed in Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides’s Design Patterns: Elements of Reusable Object-Oriented Software in 1994. By reading this book, I’ve acquired skills in: programming design patterns, basic UML modeling notation, ability to select appropriate patterns for given scenarios and advanced language features of C# 3.0. I highly recommend this book.

The strategy pattern enables a client to choose which algorithm to use from a range of supported algorithms and gives it a simple way to access it for ex. you have an News syndication service and you want to give you users the ability to grab those news in RSS or ATOM. In this case the scenario was to choose whether to process xml or text files.

Design

The key players for strategy patterns are as follows:

1. Context - Contains an IStrategy object’s algorithm in which we’re working on
2. IStrategy - Defines an interface common to all the strategies
3. TextFileImporter, XmlFileImporter - Classes that include algorithms that implement the IStrategy interface

Below you have the UML diagram:

Strategy Pattern UML Diagram

Implementation

The IStrategy interface is used to define a contract that is shared between TextFileImporter and XmlFileImporter.

namespace FileImporter.BusinessLogic
{
    ///
    /// A common interface to all supported file types
    ///
    public interface IStrategy
    {
        XDocument ImportOrders();
    }
}

Both TextFileImporter and XmlFileImporter classes implement IStrategy interface and they have a constructor which takes the file path as parameter.

namespace FileImporter.BusinessLogic
{
    public class TextFileImporter:IStrategy
    {
        private string _path;
 
        public TextFileImporter(string path)
        {
            this._path = path;
        }
 
        #region IStrategy Members
 
        public XDocument ImportOrders()
        {
            XDocument doc = XDocument.Load(_path);
            return doc;
        }        
 
        #endregion
    }
 
    public class XmlFileImporter:IStrategy
    {
        private string _path;
 
        public XmlFileImporter(string path)
        {
            this._path = path;
        }
 
        #region IStrategy Members
 
        public  XDocument ImportOrders()
        {
            XDocument doc = new XDocument();
            doc = XDocument.Load(_path);
            return doc;
        }        
 
        #endregion
    }
}

Here the context FileImporter points to a strategy and delegates to it. If a TextFileImporter is passed to the constructor than the TextFileImporter algorithm will take place and vise versa.

namespace FileImporter.BusinessLogic
{
    public class FileImporter
    {
        private IStrategy _strategy;              
 
        public FileImporter(IStrategy strategy)
        {
            _strategy = strategy;
        }
 
        public void ImportOrders()
        {
            XDocument xmlDoc = _strategy.ImportOrders();
            SqlHelper.InsertOrders(xmlDoc);
        }
    }
}

And here is where the decision making process takes place. Here the client can choose whether to use the XmlFileImporter or TextFileImporter. This is a code snippet from a windows service (more on this on later posts) which monitors a given directory and whenever a new file is created, it checks what type of file is (.xml or .txt) and based on the file extension if uses an appropriate strategy.

private void watcher_Created(object sender, System.IO.FileSystemEventArgs e)
{
    if (File.Exists(e.FullPath))
   {
        FileImporter.BusinessLogic.FileImporter importer = null;
        string ext = e.Name.Substring(e.Name.IndexOf('.'), 4).ToLower();
 
        switch (ext)
       {
             case ".xml":
                   importer = new FileImporter.BusinessLogic.FileImporter(new XmlFileImporter(e.FullPath));
                   break;
             case ".txt":
                   importer = new FileImporter.BusinessLogic.FileImporter(new TextFileImporter(e.FullPath));
                   break;
             default:
                   break;
        }
        if (importer != null)
        {
              Thread thr = new Thread(new ThreadStart(importer.ImportOrders));
              thr.Start();
        }
   }
}

Hope this helps

So I drank my coffee and started brainstorming on how I could accomplish this task the best way I could, always keeping in mind that I would have to finish it during the day. The task was peace of cake, I could do it in two hours, but the challenge was on UI. How to make it more dynamic (allowing users to enter multiple previous job positions, multiple phone numbers, multiple addresses etc.) and give users a greater experience on using the app. I wanted to accomplish this with no postbacks at all.

So in this case, the answer to life, the universe, and everything for me it was jQuery.

You’ve probably heard about jQuery, The Write Less, Do More JavaScript Framework. For those who didn’t have the chance to get their hands into jQuery, let me summarize it for you:

• It’s a lightweight JavaScript framework (less than 20 KB)
• Access DOM element using CSS selectors.
• Needless to check for null objects
• Uses chains of actions
• MVC JavaScript Architecture
• Simple and very clean … the SPARTAN WAY
• CSS 3.0 compliant
• Cross-Browser
• Extensible (support for plugins)
• And a great community support

And without further ado, let’s do that voodoo that we do do so well.

Below you have a screenshot of the above scenario.

As you can see, the job position and company name are added based on user desire and are appended dynamically to the DOM. Initially I’ve defined only the FamilyName and the FirstName of the applicant. Then I’ve defined the container workContainer in which after the DOM is ready, are initialized the first controls
[ updated ]

<% using (Html.BeginForm("Result", "Home"))
       { %>
        <fieldset>
            <legend>Your Information</legend>
            <table>
                <tr>
                    <td align="right" valign="top">
                        Family Name:
                    </td>
                    <td align="left" valign="top">
                        <%=Html.TextBox("FamilyName", "", new { @class = "txt", style = "width: 200px" })%>
                    </td>
                </tr>
                <tr>
                    <td align="right" valign="top">
                        First Name:
                    </td>
                    <td align="left" valign="top">
                        <%=Html.TextBox("FirstName", "", new { @class = "txt", style = "width: 200px" })%>
                    </td>
                </tr>
                <tr>
                    <td align="right" valign="top">
                        ...
                    </td>
                    <td align="left" valign="top">
                        ...
                    </td>
                </tr>
                <tr>
                    <td align="right" valign="top">
                        ...
                    </td>
                    <td align="left" valign="top">
                        ...
                    </td>
                </tr>
                <tr>
                    <td align="right" valign="top">
                        Work Experience?
                    </td>
                    <td align="left" valign="top">
                        <div id="workContainer">
                        </div>
                    </td>
                </tr>
            </table>
            <%= Html.AntiForgeryToken() %>
            <p>
                <input type="submit" value="Apply For this Job" />
            </p>
        </fieldset>
    <%} %>

<script type="text/javascript">            
	//wait until DOM is ready
	$(function() {
 
		//prepare initial controls
		$('<table id="tblWork"><thead><tr><th>Position</th><th>Company</th><th>&nbsp;</th></tr></thead><tbody><tr><td><input type="text" name="position" /></td><td><input type="text" name="company" /></td><td>&nbsp;</td></tr></tbody></table>')
			.append('<a href="#" id="addAnother" class="add">Add Another</a>')
			.prependTo('#workContainer');                    
 
		//atach an event handler to the addAnother link
		$("#addAnother").click(function() {
			  //get the whole table                                           
			  var $tblWork = $("table#tblWork");                      
 
			  //add row at the end of the table
			  $("table#tblWork tr:last").after('<tr><td><input type="text" name="position" /></td><td><input type="text" name="company" /></td><td>&nbsp;</td><td><a href="#" class="delete">Remove</a></td></tr>');
 
			  //find all links with "delete" class and atach the handler
			  $tblWork.find('a.delete').click(function() {              
				//remove the current table row                                      
				$(this).parent().parent().remove();
			  });                      
 
		});            
	});            
 
</script>

The classes defined in this project are Applicant and WorkExperience.

namespace jQueryLifeSaviour.Entities
{
    public class WorkExperience
    {
        public string Position { get; set; }
        public string Company { get; set; }
    }
}

namespace jQueryLifeSaviour.Entities
{
   public class Applicant
    {
        public string FamilyName { get; set; }
        public string FirstName { get; set; }
        public List<WorkExperience> Experience { get; set; }
    }
}

And here is the action which occurs after you click on Apply for this job button.

/// Get user input posted by view.
/// Accepts only POST HTTP Methods,
/// although in this case the GET would be just fine since we are not dealing with sensitive data
///The collection of posted form elements
/// The current view (in this case Result)
[AcceptVerbs(HttpVerbs.Post)]
public ActionResult Result(FormCollection form)
{
     //create a new intance of Applicant class
     Applicant obj = new Applicant
     {
          FamilyName = form["FamilyName"],
          FirstName = form["FirstName"],
          Experience = new List<WorkExperience>()
     };
 
     //hold all input fields regarding company info
     string[] companies = form.GetValues("company");
 
     //hold all input fields regarding job position
     string[] positions = form.GetValues("position");
 
     //iterate through posted work experience and fill the WorkExperience list
     for (int i = 0; i < positions.Length; i++)
     {
          obj.Experience.Add(new WorkExperience
          {
               Position = (positions[i]),
               Company = companies[i]
          });
      }
      ViewData["Applicant"] = obj;
      return View();
}

I’ve been using jQuery for a while and it made me realize that life is so much easier when using jQuery. With jQuery, JavaScript is no more “the necessary evil”, it’s even fun to code with.

You can download the full project here. This demo is developed on ASP.NET MVC 1.0 Framework, so you must install it in prior, otherwise you want be able to open it.