static void MapContainerTest(Args _args)
{
    Map                     custNotesMap;
    Container               custContainer;
    CustTable               custTable;
    SalesSourceSystemId     admarcSystemId = "DPRADM";
    Container               conCustDetails;
        str                     admarcAccountId = "000123456";
    ;
 
    custNotesMap = new Map(Types::String, Types::Container);
    while select AdmarcAccountId, RecId, TableId, dataAreaId, PartyId from custTable where custTable.AdmarcSystemId == admarcSystemId
    {
        custContainer = conNull();
        custContainer = [custTable.RecId, custTable.TableId, custTable.dataAreaId, custTable.PartyId];
 
        custNotesMap.insert(custTable.AdmarcAccountId, custContainer);
    }
 
    if (custNotesMap.exists(admarcAccountId))
        conCustDetails = custNotesMap.lookup(admarcAccountId);
    else
        error("Customer not found.");
 
    info(strfmt("RecId: %1", conpeek(conCustDetails, 1)));
    info(strfmt("TableId: %1", conpeek(conCustDetails, 2)));
    info(strfmt("dataAreaId: %1", conpeek(conCustDetails, 3)));
    info(strfmt("PartyId: %1", conpeek(conCustDetails, 4)));
}

In fact, it’s pretty fast and I’m using similar caching technique all over the place to speed up large jobs.

Given a table with columns:
A: int, primary key, identity
B: int, not null

How can I set a default for column B to be the value in column A?

This is an interesting problem on a couple levels. First, a computed column won’t work, because we need the ability to arbitrarily update column B. We could program a trigger, but I prefer to avoid them when possible. Preferably, we could actualize the purpose of the DEFAULT option. Unfortunately, this isn’t immediately an apparent choice because SQL Server doesn’t allow you to reference a column in a DEFAULT specification. In fact, according to BOL, “Only a constant value, such as a character string; a scalar function (either a system, user-defined, or CLR function); or NULL can be used as a default.”

Fortunately, the column which we’re trying to set a default from had an identity property, and system functions dealing with identity values is the key to using the DEFAULT specification. First, a little code:

CREATE TABLE dbo.IdentDefault
(
	A INT NOT NULL IDENTITY (1, 1) PRIMARY KEY,
	B INT NOT NULL DEFAULT SCOPE_IDENTITY()
)
 
INSERT INTO dbo.IdentDefault DEFAULT VALUES
INSERT INTO dbo.IdentDefault DEFAULT VALUES
INSERT INTO dbo.IdentDefault DEFAULT VALUES
 
UPDATE dbo.IdentDefault SET B = 10 WHERE A = 1
 
SELECT * FROM dbo.IdentDefault

And the result:

A           B
----------- -----------
1           10
2           2
3           3

As you can see from the above result set, column B defaults to whatever column A contains, yet we can still update column B to whatever value necessary.

• File Name: en_office_professional_plus_2010_beta_x64_x16-19234.exe
• Size: 749.87 (MB)
• Date Posted (UTC): 11/16/2009 7:21:24 AM
• ISO/CRC: D5C14D40
• SHA1: D07BC0DEE307E05F955CE44825F85084B94595B8

• File Name: en_office_professional_plus_2010_beta_x86_x16-19227.exe
• Size: 684.48 (MB)
• Date Posted (UTC): 11/16/2009 7:21:23 AM
• ISO/CRC: D3ACD2EF
• SHA1: F219E1D7FE830DCD6A796FAFEA3A5D0D4662EE89

(via Neowin)

The Setup

• Windows 7 64-bit
• Visual Studio 2008
• SQL Server 2008 64-bit

The Process

1. Create a signing key (See also, How to: Create a Public/Private Key Pair)
   1. Open Visual Studio 2008 command Prompt – the regular command prompt will not work
   2. Change to a friendly directory: cd %userprofile%\Desktop
   3. Create the key file: sn -k key.snk
2. Sign the assembly – There are a few ways to do this, but I found this to be the easiest. If you want to sign it some other way, check out How to: Sign an Assembly with a Strong Name
   1. Right-click the Project
   2. Select “Properties”
   3. Navigate to the “Signing” tab
   4. Browse to strong name key file (which was created in the previous step)
   5. Recompile the project
3. Copy the re-compiled assembly to your GAC
   1. gacutil -i “C:\Path\to\CustomAssemblyName.dll”
4. Copy assembly to “%programfiles(x86)%\Microsoft SQL Server\100\SDK\Assemblies”
5. Add reference in script task. Repeat this for every Script Task you want to access this assembly from
   1. Right-click References
   2. Click “Add Reference…”
      

      Add Reference...

   3. On the .NET tab, scroll to find your assembly
   4. Press “OK”
   5. The Assembly should now appear under the References list
6. Add a reference to the assembly in code, at the top
   1. (C#) Using CustomAssemblyName;
   2. (VB.NET) Imports CustomAssemblyName
7. You should now have full access to the imported DLL

Caveats

This method works pretty well, but deployment isn’t exactly seamless – you’ll have to repeat this for each server and re-register & copy the DLL separately for any updates. Additionally, there is no way to globally add the assembly reference to the entire project or package. Instead, you’ll have to repeat step 6 (adding the reference) for every Script Task.

Steps

1. First, fire up Visual Studio (2005 or 2008 – it doesn’t matter).
2. Create a new project – name it something clever, like “RegEx”
3. After creating the project, you should be prompted to connect to a database where you’ll eventually want to deploy the project. This is completely optional and can be changed later.
4. Right-click the project name (“RegEx”) and choose Add → User-Defined Function
   

   Add User Defined Function

5. Name the file RegExMatch.
6. Paste the following code into that file
7. When done, simple build (Ctrl+Shift+B) and deploy (Right-click the project name (“RegEx”) → Deploy).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

using System;
using System.Data;
using System.Data.SqlClient;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;
using System.Text.RegularExpressions;
 
public partial class UserDefinedFunctions
{
    [Microsoft.SqlServer.Server.SqlFunction(IsDeterministic = true, IsPrecise = true)]
    public static SqlString RegExMatch(SqlString expression, SqlString pattern)
    {
        if (expression.IsNull || pattern.IsNull)
            return SqlString.Null;
 
        Match match = new Regex(pattern.ToString()).Match(expression.ToString());
 
        return match.Success ? new SqlString(match.Value) : SqlString.Null;
 
    }
};

Code Explanation

• Line 1-6: Including necessary assemblies. The only item you need to add is line 6 – System.Text.RegularExpressions
• Line 11: We indicate the function requires 2 parameters, the input string and the regular expression to apply.
• Line 13-14: Check if either input string is NULL. If so, return NULL and do nothing else.
• Line 16: There’s a lot packed on this line, but essentially, it creates an object named match based on the results of the regular expression match operation.
• Line 18: Use the ternary operator to check if the match was a success. If so, return the matching string. Otherwise, return a NULL.

Examples

We’re going to use a simple regular expression to check for a valid US postal code (AKA Zipcode + 4):

^\d{5}(-\d{4})?$

This regular expressions checks for exactly 5 digits followed by an option group of hyphen and 4 more digits.

SELECT
	  dbo.RegExMatch('90210','^\d{5}(-\d{4})?$')
	, dbo.RegExMatch('90210-1234','^\d{5}(-\d{4})?$')
	, dbo.RegExMatch('90210-','^\d{5}(-\d{4})?$')
	, dbo.RegExMatch('9021A','^\d{5}(-\d{4})?$')

And results:

90210	90210-1234	NULL	NULL

Other notes

If you need to change the target database, do so in the project’s properties:

1. Right-click the proeject name (“RegEx”) → Properties
2. Select the Database tab (2nd item from the bottom)
3. Click “Browse…” to create and test the connection string.
   

   Database Properties

Thanks to Jeff’s SQL Server Blog for the initial Regular Expression Replace code.

You can, of course download the images through the normal MSDN channels, but speed is limited to about 30KB/sec due to demand. Fortunately, MSDN Top Downloads also hosts the images through Akamai and I’m getting 1-1.5MB/sec from here.

Here’s a list of everything that’s available:

• Windows 7 Ultimate (x64) – DVD (English)
  • File Name: en_windows_7_ultimate_x64_dvd_x15-65922.iso
  • Date Posted (UTC): 8/6/2009 9:59:54 AM
  • SHA1: 326327CC2FF9F05379F5058C41BE6BC5E004BAA7
  • ISO/CRC: 1F1257CA
  • Size: 3,075.30 (MB)
• Windows 7 Ultimate (x86) – DVD (English)
  • File Name: en_windows_7_ultimate_x86_dvd_x15-65921.iso
  • Date Posted (UTC): 8/6/2009 9:59:54 AM
  • SHA1: 5395DC4B38F7BDB1E005FF414DEEDFDB16DBF610
  • ISO/CRC: C1C20F76
  • Size: 2,385.99 (MB)
• Windows 7 Enterprise (x64) – DVD (English)
  • File Name: en_windows_7_enterprise_x64_dvd_x15-70749.iso
  • Date Posted (UTC): 8/6/2009 9:59:54 AM
  • SHA1: A89DCE706D527206CB464EF86ACD3A3D13A332DB
  • ISO/CRC: D4597619
  • Size: 2,976.62 (MB)
• Windows 7 Enterprise (x86) – DVD (English)
  • File Name: en_windows_7_enterprise_x86_dvd_x15-70745.iso
  • Date Posted (UTC): 8/6/2009 9:59:54 AM
  • SHA1: C6B905E48FDB6CB5BFCA967715A64461B812D40C
  • ISO/CRC: 6A9B5097
  • Size: 2,289.20 (MB)
• Windows 7 Professional (x64) – DVD (English)
  • File Name: en_windows_7_professional_x64_dvd_x15-65805.iso
  • Date Posted (UTC): 8/6/2009 9:59:54 AM
  • SHA1: 50127304441A793EE51B3F501289F6599A559E9F
  • ISO/CRC: 502C42C1
  • Size: 3,075.30 (MB)
• Windows 7 Professional (x86) – DVD (English)
  • File Name: en_windows_7_professional_x86_dvd_x15-65804.iso
  • Date Posted (UTC): 8/6/2009 9:59:54 AM
  • SHA1: 697FA06554502FB21D30275273B25747299C020D
  • ISO/CRC: 578725D1
  • Size: 2,385.99 (MB)
• Windows 7 Home Premium (x64) – DVD (English)
  • File Name: en_windows_7_home_premium_x64_dvd_x15-65733.iso
  • Date Posted (UTC): 8/6/2009 9:59:54 AM
  • SHA1: 336779EA6B65F63E11A609B4D021439C47AB315B
  • ISO/CRC: 56D954E4
  • 3,075.30 (MB)
• Windows 7 Home Premium (x86) – DVD (English)
  • File Name: en_windows_7_home_premium_x86_dvd_x15-65732.iso
  • Date Posted (UTC): 8/6/2009 9:59:54 AM
  • SHA1: CC9D8220B2179E784D85BF1EA98D2EE2190D534F
  • ISO/CRC: 5DF6DBA0
  • Size: 2,385.99 (MB)
• Windows 7 Home Basic (x86) – DVD (English)
  • File Name: en_windows_7_home_basic_x86_dvd_x15-65654.iso
  • Date Posted (UTC): 8/6/2009 9:59:54 AM
  • SHA1: 101574FAA17FDB430BB027271EF0A58F0E18AD47
  • ISO/CRC: 2B06C5CC
  • Size: 2,385.99 (MB)
• Windows 7 Starter (x86) – DVD (English)
  • File Name: en_windows_7_starter_x86_dvd_x15-68956.iso
  • Date Posted (UTC): 8/6/2009 9:59:54 AM
  • SHA1: 5DC1457BC4B3D94097F499B15DFDB3C21DADCDF5
  • ISO/CRC: 43DE3418
  • 2,385.99 (MB)

1. Download and install MySQL Connector/NET 6.0
2. Start a new Integration Services project in BIDS
3. Right-click in Connection Managers and create a new ADO.NET Connection

   

4. In the Provider dropdown, expand .Net Providers and select MySQL Data Provider. Press "OK"

   

5. Fill out the Server name, User name, Password and select the database name for the target MySQL server. Be sure to test the connection and press “OK”

   

6. Rename the connection to “MySQLDB”

   

7. Open up the Toolbox and drag a Data Flow Task from the toolbox onto the Control Flow surface
   

   Add Dataflow Task

8. Double-click the Data Flow Task to switch to the Data Flow view
9. Create a new variable, “MySQLResult” with the Data Type of Object. We will be using this as the final destination for the data, so we don’t need to connect to a file or database to store the data from this test
   

   MySQLResult Variable

10. Drag a new DataReader Source component onto the Data Flow surface
    

    Add DataReader Source

11. Double-click the DataReader Source to open the Advanced Editor. On the Connection Managers tab, select the previously-created MySQLDB connection
    

    DataReader Source Connection Managers

12. Switch to the Component Properties tab and enter the SQL query in the SqlCommand property. Note that the query must be compatible with MySQL syntax, not SQL Server.
    

    DataReader Source Component Properties

13. Switch to the Column Mappings tab to verify that the query is successful and the all the columns were pulled from the database. When done, press “OK”.
    

    DataReader Source Column Mappings

14. Create a new Recordset Destination by dragging it from the toolbox to the Data Flow surface
    

    Add Recordset Destination

15. Drag the green Data Flow Path from DataReader Source to Recordset Destination, so they connect
    

    Connect Source to Destination

16. Double-click the Recordset Destination to open its Advanced Editor
17. Under Custom Properties, select the dropdown for VariableName and select the variable we created before, User::MySQLResult
    

    Recordset Destination Component Properties

18. Switch to the Input Columns tab and select those columns that you want stored in the Recordset Destination. When complete, click “OK”
    

    Recordset Destination Input Columns

19. Right-click the green Data Flow Path and choose “Data Viewers…”
    

    Data Flow Path Data Viewers

20. Select “Data Viewers” from the left pane and click the “Add…” button
    

    Data Flow Path Editor

21. Under the General tab, select Grid and press “OK”
    

    Configure Data Viewer

22. Run the package
23. If you’ve done everything correctly, you should see a Data Reader Output Data Viewer window pop up with the contents of the query we specified earlier.
    

    Data Viewer Output

SQL Server Integration Services makes connecting to other systems very easy. The MySQL ADO.NET provider works well, but requires more configuration than a native Source component.

Actual employee structure to be flattened

This structure will act as our example for the Development Department. The Department Head (Employee 0) has asked for a report of all employees within each team of the development group. Notice that different groups have varying levels of depth. The Database team only has a Manager with two direct reports. The UI team is a single person. The Middle Tier group is much larger, with a Manager having two direct reports, and one of those employees having several employees beneath him. The requested report should group all employees, flattening the relationship to a single Manager, but excluding himself (since that would mean every employee would simply roll up to him). This “Desired Relationship” is represented below:

The desired result of the query

To recreate this scenario, I’m providing some code for both the setup and query. If you’re not familiar with Common Table Expressions, I would suggest that you familiarize yourself with the SQL Server BOL entry. The main concept you should understand to be able to adapt this to your own data is that for a CTE to act recursively, you need both an anchor and recursive query. I’ll explain their parts later.

First, let’s instantiate the tables and populate them with data:

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

USE tempdb
go
 
IF OBJECT_ID('dbo.Employees') IS not null
	DROP TABLE dbo.Employees
go
 
CREATE TABLE dbo.Employees
(
	  EmployeeID INT PRIMARY KEY
	, EmployeeName VARCHAR(50) not null
	, ManagerEmployeeID INT null
)
go
 
INSERT INTO dbo.Employees (EmployeeID, EmployeeName, ManagerEmployeeID)
SELECT 0, 'Employee 0', null
UNION all
SELECT 1, 'Employee 1', 0
UNION all
SELECT 2, 'Employee 2', 0
UNION all
SELECT 3, 'Employee 3', 0
UNION all
SELECT 4, 'Employee 1.1', 1
UNION all
SELECT 5, 'Employee 1.2', 1
UNION all
SELECT 6, 'Employee 3.1', 3
UNION all
SELECT 7, 'Employee 3.2', 3
UNION all
SELECT 8, 'Employee 3.1.1', 6
UNION all
SELECT 9, 'Employee 3.1.1.1', 8
go

This script will simply create the example employees table and populate it with data to relationally represent what is displayed in the first picture. Here are what the various lines accomplish:

• 1-2: Switch the database context to tempdb. Since the contents of tempdb are cleared upon service restart, we’re simply ensuring that this will be cleaned up eventually.
• 4-6: Check if dbo.Employees exists. If so, drop it.
• 8-14: Create a table to hold our example data.
• 16-36: Manually populate the example data. Note that we’re using a UNION ALL between the selects, so only a single INSERT occurs.

As for the query to manipulate this data, here is the actual CTE:

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

-- Use a CTE to flatten an organization structure to each department
WITH AllMyChildren (ManagerEmployeeID, EmployeeID, GroupManagerID, EmployeeName, DEPTH)
AS
(
	-- The anchor statement. This selects each department head
	-- The important part is to alias the original EmployeeID as the GroupManagerID
	SELECT ManagerEmployeeID, EmployeeID, EmployeeID [GroupManagerID], EmployeeName, 0 [DEPTH]
	FROM dbo.Employees WHERE EmployeeID in
		-- We want all employees 1 level below below a certain level, so we'll utilize a subquery to find them
		(
		-- Get EmployeeIDs that are children to their common parent
		SELECT EmployeeID FROM dbo.Employees WHERE ManagerEmployeeID = 0
		)
	UNION ALL
	-- The recursive statement which finds all employees under each department
	SELECT pc.ManagerEmployeeID, pc.EmployeeID, amc.GroupManagerID, pc.EmployeeName, DEPTH + 1
	FROM dbo.Employees pc
	INNER join AllMyChildren amc ON pc.ManagerEmployeeID = amc.EmployeeID
)
-- The CTE is primed, but we still need to execute it with the statement below
SELECT EmployeeName, GroupManagerID, DEPTH 
FROM AllMyChildren
ORDER BY GroupManagerID, DEPTH
-- Use the MAXRECURSION query hint to avoid default recursion limit of 100
OPTION (MAXRECURSION 0)

I’ve commented liberally, but I’ll go through this line-by-line to explain it in more detail.

• 2-4: Define the CTE (AllMyChildren) and the columns that it will output (ManagerEmployeeID, EmployeeID, GroupManagerID, EmployeeName, Depth)
• 7-8: This is the anchor statement. SELECT the fields we eventually want outputted. The key to this is that EmployeeID is being included a second time, but aliased as GroupManagerID.
• 10-13: This is a subquery in the WHERE condition of the anchor statement. Because we want to discard some levels (only the topmost level in our example), we need to tell the anchor to fetch all children whose parent EmployeeID is 0. Adjust this sub-query to affect at what level the teams should roll up to.
• 14-18: UNION ALL the anchor to the recursive portion of the CTE. The recursive part of the query is similar to the anchor in that it must SELECT similar columns. Notice that it again selects from dbo.Employees, but it also performs an INNER JOIN against the CTE, linking the EmployeeID and ManagerEmployeeID. This is what causes to recursion to occur. Additionally, we increment Depth by 1. The inclusion of the level is completely optional in the CTE, but may be helpful for reporting.
• 19: Close the CTE block. At this point, it is defined, but we have yet to execute it.
• 21-23: Perform a SELECT against the CTE to start it.
• 25: By default, recursion in Common Table Expressions is limited to 100 iterations. If you anticipate having more than 100 records, you’ll need to specify MAXRECURSION 0. When testing, you can limit it to any number up to 32,767 to prevent wild-running queries. Here – since this is tested and working – we specify “0″ for unlimited iterations.

And this is the result of the above query:

The tabular results of the query

One solution to this problem is to start the programs manually, which is monotonous. A much better solution is to control the exact startup sequence, giving each program a small delay to fully load before starting the next program. A solution I used in the past for Windows was a batch file. This suffers from a couple of problems:

1. By default, there is no “sleep” command. You can install the Windows 2003 Administrator Toolkit for the functionality, or resort to a ping delay trick. Both of these are less-than-ideal.
2. This is 2009. Batch files aren’t exactly cool.

To overcome these issues, I took a gander at my latest favorite scripting language, PowerShell; it handily solves both issues. This is a very easy hack and to accomplish it, there are only a few steps. The only considerations for this project is to ensure that PowerShell v1 or v2 is installed and configured to run scripts locally. With those assumptions, let’s get started:

Create the script

Let’s get directly to the fun stuff. Because we’re only performing 2 types of actions, the script itself is actually very simple. The hardest part of this step is locating each program. Create a new PowerShell script called Startup.ps1 and save it in your (My) Documents folder. Copy my example script to get started:

Start-Sleep –s 15
& 'C:\Program Files\Zecter\ZumoDrive\zumodrive.exe'
Start-Sleep –s 5
& 'C:\Program Files\Dropbox\Dropbox.exe' /home
Start-Sleep –s 5
& 'C:\Program Files\Digsby\Digsby.exe'
Start-Sleep –s 15
& 'C:\Program Files\KeePass Password Safe\KeePass.exe'

The Start-Sleep command suspends the script for a specific amount of time. By specifying the “-s 15″ parameter, we provide a delay of 15 seconds. I provide an initial delay on load of the script simply to ensure the OS has loaded other necessary modules.

The second type of line is the actual execution of a program. The command is an ampersand (&) followed by the program path enclosed in single quotes. Any program parameters can go after the path name. The use of single quotes (') indicates we are passing a literal string. If we were to use double-quotes instead, PowerShell would attempt to interpret any variables enclosed, of which we have none.

Cofigure your script with the programs you want started at logon. A good solution to this is to check the properties of each program in your start menu. For anything not in your Start Menu, you’ll have to locate the application. We’ll test the script a bit later.

Turn off automatic startups

This step is a bit more complicated, because you may need to go into each program and turn off the “Automatically start when I log on to Windows” option. A quick way to head off most of these issues is through the msconfig tool. Simply start msconfig (XP: Start→Run→msconfig. Vista: Start→mscofig).

Run msconfig utility

Switch to the Startup tab and uncheck items you plan to load through your custom logon script. When done, click “OK”.

System Configuration Startup

Link your Startup Script

The final step is to actually enable the startup script. Navigate to your Startup program folder. The easiest way to accomplish this is to find the Startup folder in your Start Menu, Right-click, and select “Open”.

Open Startup folder

A new folder will open and you want to create a new shortcut here. Right-click in an empty spot in the folder and choose New→Shortcut.

New Shortcut

A Wizard will open prompting your for the location of the item. In the text box, put “powershell .\Startup.ps1″.

Shortcut Location

Technically, you can provide the absolute path to the item, but we’ll utilize a slightly different method. Click “Next” and name the shortcut to your liking, maybe, “Default Startup”.

Shortcut Name

When the wizard closes, switch back to the Startup folder and you should see your new shortcut. Right-click the shortcut and select “Properties”.

Properties link

Take note that the “Target” field has been expanded to the full path to PowerShell. For example, “C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe .\Startup.ps1″. We want to edit the field directly below it, labeled “Start in”. Delete the contents of the field and replace it with "%USERPROFILE%\Documents" for Vista or "%USERPROFILE%\My Documents". Go ahead and include double-quotes just for completeness. When done, click “OK”.

Shortcut Properties

Testing

When you’re done, it’s best to exit all the programs and run the script, ensuring there are no errors. To correctly configure the delay times, you may want to reboot, which ensures the memory cache is clear. You can then jot down which programs need more or less time.

To test, simply double-click the shortcut. If all goes according to plan, all your programs should launch just as before. And because the shortcut it located in the Startup folder, this should happen each time you log in to your profile.

For me, this is a great, simple solution using a tool I already have installed on my computer. Additionally, as my needs change, it gives me ultimate flexibility in the future. I could even go so far as to conditionally launch programs depending on aspects like date and time.