Let’s see an example.

1
2
3
4
5

SELECT 1 MyValue
 
UNION
 
SELECT 1 MyValue

Here we are combining two sets of data which each contain a single record, 1. If you execute this command, you will get back a single row which contains the value 1 in the MyValue column. This is because the new value we union in already existed in the first data set, so it did not include it.

Let’s modify our query to use Union All.

1
2
3
4
5

SELECT 1 MyValue
 
UNION ALL
 
SELECT 1 MyValue

We now get back a set with two records, the 1 from the first set AND the 1 from the second set.

Simple L2S Examples

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

using (DBDataContext db = new DBDataContext())
{
	// get all
	var search = from t in dc.MyTable
		           select t;
 
        // this will return all the records
	List<MyTable> all = search.ToList();
 
	// get all (example 2) This one doesn't use a search variable.
	List<MyTable> all2 = dc.MyTable.ToList();
 
	// get single
	var search2 = from t in dc.MyTable
		              where t.ID == 1
			      select t;
 
        // if none is found, then record will be NULL.
	MyTable record = search2.SingleOrDefault();
 
	// get single (example 2) This one uses a predicate which defines
        // 's' as a placeholder, and then sets the conditions for s to be s.ID == 1.
	MyTable record2 = dc.MyTable.SingleOrDefault(s => s.ID == 1);
 
        // update a value in the record
        record2.Value1 = "Hello!";
        db.SubmitChanges();
 
        // delete the record
        db.MyTable.DeleteOnSubmit(record2);
        db.SubmitChanges();
}

A typical insert query looks like this.

1
2
3
4
5
6
7
8
9
10

INSERT INTO Person 
     (Name, 
      Address, 
      Phone
     )
VALUES 
     ('Test Guy', 
      '123 Test St', 
      '555-5555'
     )

This works fine for just one row. But what if we had another table which contained the information we needed, and had 100000 rows that we wanted to copy over? Let’s just combine our INSERT with a SELECT!

1
2
3
4
5
6
7
8
9
10
11

INSERT INTO Person 
     (Name, 
      Address, 
      Phone
     )
SELECT
     Name,
     Address,
     Phone
FROM
     TableThatHasValues

It’s that easy! The SELECT query will execute and the results of that select query will be piped into the INSERT command, inserting every single row.

Let’s say we have a query like this.

1
2
3
4
5
6

SELECT
     *
FROM
     Animals a
     INNER JOIN Animal_Details ad
          ON a.AnimalID = ad.AnimalID

This table will join together two tables and pull in the details of whatever animals are in the animals table. I just made this up quickly. Let’s have SQL save that to a new table.

1
2
3
4
5
6
7
8

SELECT
     *
INTO 
     AnimalDetailsCombined
FROM
     Animals a
     INNER JOIN Animal_Details ad
          ON a.AnimalID = ad.AnimalID

This query will create a brand new table called AnimalDetailsCombined and save the results of that query into the table. If you wanted to save to a temporary table, which would be deleted once the connection is closed, just add a hashtag (#) in front of the table name.

1
2
3
4
5
6
7
8

SELECT
     *
INTO 
     #AnimalDetailsCombined
FROM
     Animals a
     INNER JOIN Animal_Details ad
          ON a.AnimalID = ad.AnimalID

You now have a temporary table called #AnimalDetailsCombined with is the result of the query.

There will be a classic gameplay mode called casual and also an arcade mode where you find as many words as you can in a given amount of time.

I began development today on the classes which will populate the word field. I had to learn a few new details about NSString that I didn’t know before. I am still relatively new to objective-c and it is quite a departure from C# which I develop with every day.

It is going to use cocos2d in order to get some fancy graphic effects.

Good thing I began programming with standard c years ago or I’d be completely lost!

The good news is that I am now the proud owner of a shiny new iPad. The market for iPad applications is relatively small right now, also. So I am going to shift over to writing a game for the iPad. I have an idea that is going to be based off of some old code that I wrote when playing around with Irrlicht. It’s a game much like Homeworld though not quite as complex.

I’ve deleted my asteroids plan. I’m moving on!

Here is the first post! (from http://davesgamedev.wordpress.com/)

This is a blog I decided to create to chronicle my development of iPhone/iPod games. The first game I released, Smiled Out, has been received “…okay…” by the market and I think that what it is missing is exposure. Therefore, this blog will chronicle my efforts at game development in order to attempt to build some kind of excitement about my games.

I will post code, plans, screenshots, etc.

First, my plan for my next iPhone/iPod Touch game.

1. Stop watching so much television.
2. Quit getting distracted reading news sites or Wikipedia.
3. Write a design document. (I have this already in the form of notes and a few drawings..)
4. Write a technical design doc. For my next game, I will be using Cocos2D and Chipmunk, along with a version of an old engine of mine called Dusty Engine that I have ported to Objective-C.
5. Don’t focus on graphics to begin with, make the game WORK and then make it pretty.
6. Don’t ignore my wife.

I work full time as a business software developer so #1 and #2 are very important, as it gets easy to be distracted and burned out when writing my own code. Adhering very closely to #6 will also make the development process go much smoother.

My next game will be an Asteroids clone. Before you click away, I have a very good idea for controlling the ship, and with Chipmunk physics I think it will blow away the competition. I was going to call it “StarRoids” until I found out that an old Mac game from the 1980s had that exact name and I don’t want those kinds of problems. Part of the failure of Smiled Out is that I am afraid to mention “Lights Out” anywhere official with it since Lights Out is trademarked.

So I haven’t yet named my project. Let’s just call it “Unnamed Asteroids Clone” as a working title.

Check back regularly for updates.

The problem is that we have a table of time entries, the date the entries were made, and the employee who made them and we need to accrue the hours that employee worked in a given week. This is simple to do with iterators in code or cursors in T-SQL, but what fun would that be?

I’m going to simplify the problem by only looking at a single week of data. In a larger solution which looks over a larger range of dates such as a month you will need a subquery which assigns each week a number and group by that week number. In my full blown implementation of this, I used row_number() over (order by startdate) given a list of weeks with a startdate and enddate. But that is for a later post.

Let’s look at our week’s worth of data, which has 2 employees.

Table TimeEntries

As you can infer from the above, employee 1 worked overtime (more than 40 hours) starting on the 8th, and employee 2 worked no overtime, since the employee worked exactly 40 hours in that week.

Problem 1: Multiple Records in a Day The first problem we must overcome is calculating the total number of hours worked in a given day. This is because we can have an employee who puts in 4 hours in the morning and 4 hours in the afternoon. If we don’t have this in a single record, it will be difficult down the line when our complicated joins and subqueries come in.

So we build this query which will sum up the hours in a given day. We will use this in a couple of places.

1
2
3
4
5
6
7
8
9

SELECT
	te.EmployeeId,
	te.DateWorked,
	SUM(te.Hours) TotalHoursInDay
FROM
	TimeEntries te
GROUP BY
	te.EmployeeId,
	te.DateWorked

Very simple, we’re just summing up the hours per day. We’re going to use this query in several places.

Problem 2: Finding out which days are in overtime. The next thing we need to overcome is to come up with a means of determining which days should be in overtime. This is where “accrual” of sorts comes into play. We join each day’s record to every record before it. We then group that record and sum up the hours previous to the given day.

Let’s look at the query.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

SELECT
	te.EmployeeId,
	te.TotalHoursInDay,
	te.DateWorked,
	sum(previous.TotalHoursInDay) HoursUpToThisPoint,
	case when te.TotalHoursInDay + SUM(previous.TotalHoursInDay) > 40 then 'Y'
		 else 'N'
	end InOvertime
FROM
	(
		SELECT
			te.EmployeeId,
			te.DateWorked,
			SUM(te.Hours) TotalHoursInDay
		FROM
			TimeEntries te
		GROUP BY
			te.EmployeeId,
			te.DateWorked
	) te
	LEFT JOIN
	(
		SELECT
			te.EmployeeId,
			te.DateWorked,
			SUM(te.Hours) TotalHoursInDay
		FROM
			TimeEntries te
		GROUP BY
			te.EmployeeId,
			te.DateWorked
	) previous
		ON	te.EmployeeId = previous.EmployeeId AND
			te.DateWorked > previous.DateWorked
GROUP BY
	te.EmployeeId,
	te.TotalHoursInDay,
	te.DateWorked

The first subquery, te, creates a list of each day for each employee and the total hours for that day. This is to get the total current hours for the employee for the given day. We join that to the second subquery, previous. The Previous query generates a total number for all days PRIOR to the given day. (The logic comes from our join condition, te.DateWorked > previous.DateWorked)

The InOvertime flag will be used later on to determine overtime hours. It lets us know when the employee has crossed the threshold. That could probably be taken out, but it simplifies the logic later on.

So we get these results:

As you can see, this subquery determines for us the total number of hours up until the given day, and when combined with the hours worked in the given day we know if the employee is in overtime or not.

Let’s put one more wrapper around this which will total up the hours and tell us how many hours were regular hours and how many were overtime.

Here is our final query.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

SELECT
	EmployeeId,
	sum(case when InOvertime = 'N' then TotalHoursInDay
	         when InOvertime = 'Y' AND HoursUpToThisPoint < 40 then  40 - HoursUpToThisPoint
		 else 0
	end) RegularHours,
	sum(case when InOvertime = 'Y' then
		 case when HoursUpToThisPoint > 40 then TotalHoursInDay
			  else HoursUpToThisPoint + TotalHoursInDay - 40
		 end
		 else 0
	end) OTHours
FROM
(
	SELECT
		te.EmployeeId,
		te.TotalHoursInDay,
		te.DateWorked,
		sum(previous.TotalHoursInDay) HoursUpToThisPoint,
		case when te.TotalHoursInDay + SUM(previous.TotalHoursInDay) > 40 then 'Y'
			 else 'N'
		end InOvertime
	FROM
		(
			SELECT
				te.EmployeeId,
				te.DateWorked,
				SUM(te.Hours) TotalHoursInDay
			FROM
				TimeEntries te
			GROUP BY
				te.EmployeeId,
				te.DateWorked
		) te
		LEFT JOIN
		(
			SELECT
				te.EmployeeId,
				te.DateWorked,
				SUM(te.Hours) TotalHoursInDay
			FROM
				TimeEntries te
			GROUP BY
				te.EmployeeId,
				te.DateWorked
		) previous
			ON	te.EmployeeId = previous.EmployeeId AND
				te.DateWorked > previous.DateWorked
	GROUP BY
		te.EmployeeId,
		te.TotalHoursInDay,
		te.DateWorked
) HoursQuery
GROUP BY
	HoursQuery.EmployeeId

What we have done here is add some logic that acts on whether or not the a given time entry is in overtime. We group by the employee so we can aggregate hours.

If the record is in overtime, it might mean the employee is already over 40 hours or it might mean that the current record puts the employee over 40 hours. So we have to add a check that will take the difference as regular hours, since the hours that take the employee up to 40 are still regular hours.

The second check is to calculate overtime. If the time entry puts the employee over 40, then take the amount over 40 as overtime. If the employee is already over 40, then the entire entry is overtime.

I hope this post helps you have the mindset of doing as much as possible with your queries, rather than writing code to calculate values which can easily be queried.

1
2
3
4
5
6
7
8
9
10

public static void SendEmail(string to, string from, string subject, 
                             string message, string host, int port)
{
    SmtpClient c = new SmtpClient(host, port);
 
    MailMessage m = new MailMessage(from, to, subject, message);
    m.IsBodyHtml = true;
 
    c.Send(m);
}

Simple, eh? But it would fail. If I telnet’ed into their server and typed the SMTP commands to send an email, I would get a 550 5.0.0 Command Rejected” error message at the point where I try to send a “RCPT TO:” SMTP command. What’s the deal?!

Well, apparently the server did have a restriction that I had so far not known about. It had been configured with a GREET_PAUSE value for all emails. Typically that setting should only be set for incoming emails from external servers, and not for internal emails like this. But it was set for all emails.

GREET_PAUSE means that once an SMTP connection is made, the client who is connecting must WAIT until the server recognizes their connection before “blasting” SMTP commands through. Apparently SMTPClient just blasts the commands through. If a SINGLE character is received in that timespan, the server will reply as normal, but will reject any and all emails that are sent through.

I tried a couple fancy ways to make SMTPClient wait for a few seconds before sending data, but could not find an easy way. Apparently it does not support this capability out of the box (such that I could find.) So I resolved to just writing the email code myself. It’s not hard to do.

I added a greet_delay_ms integer to my parameters on my function:

1
2

public static void SendEmail(string to, string from, string subject, string message, 
                    string host, int port, int greet_delay_ms)

And replaced the simple SMTPClient code with this more complex code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public static void SendEmail(string to, string from, string subject, string message, 
                       string host, int port, int greet_delay_ms)
{
    TcpClient c = new TcpClient(host, port);
    StreamWriter sw = new StreamWriter(c.GetStream());
    StreamReader sr = new StreamReader(c.GetStream());
    string data = "";
 
    // Wait the specified amount of time before sending an email
    // could probably also just do a sr.ReadLine() and let it block
    System.Threading.Thread.Sleep(greet_delay_ms);
 
    sw.WriteLine("helo " + from.Substring(from.IndexOf("@") + 1));
    sw.Flush();
    data = sr.ReadLine();
 
    sw.WriteLine("MAIL FROM:" + from);
    sw.Flush();
    data = sr.ReadLine();
 
    sw.WriteLine("RCPT TO:" + to);
    sw.Flush();
    data = sr.ReadLine();
 
    sw.WriteLine("DATA");
    sw.Flush();
    data = sr.ReadLine();
 
    sw.WriteLine("Subject: " + subject);
    sw.Flush();
    sw.WriteLine(message);
    sw.Flush();
    sw.WriteLine(".");
    sw.Flush();
    data = sr.ReadLine();
 
    c.Client.Close();
    c.Close();
}

Once I passed in 8000 or so as the time to wait, the emails poured through just fine. 8 seconds is a while to wait, but apparently that’s what this server requires.

In my table, I have a field “PayType” which is a char(1) and has valid values “S” and “H”. These mean “Salary” and “Hourly”, respectively.

I am showing this in a ListView in my screen I’m developing. So, when editing the record, I naturally wanted a dropdown box where you can choose “Hourly” or “Salary”. Note this will only work if you know what values you want in your dropdown box. If the selections are dynamic, then you will probably have to have a databound event and build the box manually.

I wanted it to default to the selected type for the record I’m editing when I click on edit, but could not find anything in the intellisence that looked correct for my Bind() call.

1
2
3
4
5
6
7

<asp:DropDownList 
      ID="ddPayType" 
      runat="server" 
      SelectedValue=<%# Bind("PayType") %>  >;
          <asp:ListItem Text="Salary" Value = "S" />
          <asp:ListItem Text="Hourly" Value = "H" />
</asp:DropDownList>

The answer was to Bind on the “SelectedValue” parameter. I was thrown off because SelectedValue does not seem to pull up in Visual Studio 2008 as an option on the list when writing code in the markup editor. But it correctly updates the value when the Update command is executed.