When providing html links to XML files, typically the HTTP Headers will set ContentType = Plain / Text, and show up in the browser as text. The need is to provide links to Excel files in XML format, and prompt the user to download locally. Once downloaded, the user may open the XML file in Excel.

An alternate solution is to set the MIME type for files of XML extension, and open directly as a link from the browser yet rendered in Excel. This is less preferable as it dictates the behavior of all XML files, whereas the scope is for specific files as Excel and unspecified files to continue having default XML rendering.

SOLUTION: CUSTOM HEADERS

• Custom Headers to specify download as an attachment can easily be achieved by creating an Http Handler, and associating the path of required files. An Http Module could be written, but that is specific to the file extension, and there is need for some XML files to be treated as text, and others as Excel. In cases like this, a Handler is much more efficient than a Module, because it’s execution is limited to the path.
• We simply want to add a header for Content-Disposition as an attachment, and to specify the appropriate filename for download.
• The remainder of this blog post is a demo of code for this solution. If you wish, you may download the attached ZIP file to see the completed solution.

CODE: HTTP HANDLER

 In Visual Studio 2013, create a class library project called “WebCustomHttpHandler” and add a class “DownloadFileHandler” as per code given below. Error handling / comments removed for brevity.

CODE: WEB SITE

Add a reference within the web site to the class library project created earlier. This is not required, but will simplify deployment by ensuring the DLL for the Http Handler is copied to the bin directory of the web site.
Where applicable, simply provide a link to the XML file for download.
Edit the web.config file as per below. Adjust values for the path as required.

CODE: CONFIGURATION - IIS

The IIS server needs to have a Http Handler configured for the web site. This is done using the command appcmd.exe.
Reference https://technet.microsoft.com/en-us/library/jj635852.aspx
Run this in a batch file, optionally output to a log file and / or parameterize the site name, handler name, etc.

REFERENCES

Appcmd.exe (IIS 8)

https://technet.microsoft.com/en-us/library/jj635852.aspx

Add a Managed Handler Mapping (IIS 7)
https://technet.microsoft.com/en-us/library/cc753249(v=WS.10).aspx

Remove a Handler Mapping (IIS 7)
https://technet.microsoft.com/en-us/library/cc754894(v=WS.10).aspx

CONCLUSION

It's not difficult at all to create a custom Http Handler. In design of this type of functionality, it is advisable to understand when you would want a Http Handler versus Http Module.
 

OpenExcelFileDemo.zip

By having event log sources already created, the application code will write to the event log, assuming the event log source already exists. The developer can choose to write the code in a try / catch block with error handling to alternatively write to a standard event log, text file, database log, etc. according to their design, but that is out of scope for this post. I will focus only on the PowerShell script and execution of it.

This blog posting provides a code example on how to author a PowerShell script that will create event logs and event log sources. If the source already exists, it will give a message indicating such. This script is designed to be executed at time of install of the application, not during run time of the application, thus eliminating the potential security vulnerability of elevation of privileges.

This PowerShell script works without user input, where the application configuration is entered directly into the script as an array of comma delimited pairs of event logs,event log sources. Simply modify the values in the variable $eventSources and run it. In the example given, the $eventSources is configured to create 2 sources on the Application log, then create 2 new event logs with corresponding sources.

Note#1: For the development and test teams, it may be beneficial to use the PowerShell command Remove-eventLog with appropriate parameter -LogName to specify the event log name, or to use the parameter -Source to retain the event log but delete only the event log source. I highly recommend you become familiar with the usage of this command before attempting to delete anything. This functionality is useful for developing and testing purposes of this script, but is not part of the purpose of this blog, so be careful if you use this command for production systems.

Note#2 On some systems, there may be a policy that denies execution of PowerShell scripts. You can override this when calling the PowerShell.exe command by adding -ExecutionPolicy ByPass as a parameter. Policies are there for a reason, but if the script is fully reviewed, tested, and certified, it may be helpful to specify this parameter.

Note#3. Although it is possible to create event logs having greater than 8 characters in the name, if you attempt to create a second event log where the first 8 characters are the same as an existing event log, you will get an error.

# -----------------------------------------------------------------------------
 # CreateEventLogSources.ps1
 # AUTHOR: Ken O. Bonn
 # DATE: 03/29/2014
 # PURPOSE: Ensure Event Logs and Sources exist for application "MyApplication" to write events to.
 # NOTES: (1)The only customization required is to specify your event log, source pair.
 # (2)This can be run from a command prompt as below, assuming policy allows that
 # PowerShell.exe -File CreateEventLogSources.ps1
 # -----------------------------------------------------------------------------
 #
 # -----------------------------------------------------------------------------
 # CREATE EVENT LOG SOURCES IF THEY DO NOT EXIST.
 # -----------------------------------------------------------------------------
 #
 #eventSources is an array of comma delimited strings containing the Event Log followed by the event source.
 
 $eventSources = @(
 "Application,MyApplicationSource1",
 "Application,MyApplicationSource2",
 "MyAppLg1,MyApplicationSource3",
 "MyAppLg1,MyApplicationSource4",
 "MyAppLg2,MyApplicationSource5"
 )
 
 #Loop through each event log,source pair to create the source on the specified log if it does not exist.
 
 foreach($logSource in $eventSources) {
 $log = $logSource.split(",")[0]
 $source = $logSource.split(",")[1]
 if ([System.Diagnostics.EventLog]::SourceExists($source) -eq $false) {
 write-host "Creating event source $source on event log $log"
 [System.Diagnostics.EventLog]::CreateEventSource($source, $log)
 write-host -foregroundcolor green "Event source $source created"
 }
 else
 {
 write-host -foregroundcolor yellow "Warning: Event source $source already exists. Cannot create this source on Event log $log"
 }
 }
 

CreateEventLogSources.ps1

This blog post will teach you how to easily pin your site to the task bar, and to enable dynamic jump lists to enable MRU functionality. As there are related concepts of pinning via meta tags, I'm including a couple bonus features, which will be explained along the way as optional. The main features of this article are in yellow highlight below, and the bonus features are not highlighted.

1. Pin to task bar.
2. Pin static jump list to task bar.
3. Pin dynamic jump list (MRU) of task bar.
4. Pin to Windows start screen.

INCLUDED IN THIS ARTICLE:

1. User Benefits: How and why?
2. MRU Methods
1. Navigate by key of query String parameter
2. Navigate by attribute of page
3. Navigate by post
3. Developer: Give me the code!
1. Meta Tags and XML
2. JavaScript
3. JQuery
4. Images
4. Developer: Rework to support user friendly lists
1. JavaScript Changes
2. JQuery Changes
3. Final View
5. Special Considerations
6. References
7. Conclusion

USER BENEFITS: HOW AND WHY

Users want to have an easy way to return to their favorite site (much like CTRL-D works to save a favorite page), yet they visit the same page multiple times (much like storing history). If you imagine a shopping experience, a user might have found 5 items but not added them to their shopping cart. The next day, instead of searching the history for the site, they might simply find the item bookmarked to the actual page!

• Pinning to the task bar will give the user the ability to quickly reference the site from the task bar. The code provided in this article will enable users with the ability to see a static list of pages (such as help) and a dynamic list of pages (such as MRU pages).
• Pinning to the Windows start screen will give the user the ability to find the site simply by searching for it as an application (shortcut, Windows-Q) or as a tile on the windows start screen.

MRU METHODS

There are varying methods of pinning to the task bar and implementing MRU functionality, below is high level approach for three methods. The first method will get you quickly up to speed with working code and understand the concepts. The second method will be the most useful one, as this provides a friendly name to pin the pages to. The third method below possibly has limited value, despite ability to save queries, because the jump list functionality might best be used for specific results, not a table of results.

The biggest challenge to all of the methods below is to come up with a user friendly means to anchor the text of the MRU link to something that is meaningful to them.

NAVIGATE BY KEY OF QUERY STRING PARAMETER

The first method in this blog is based on navigating through pinned jump lists whereby the friendly name for the jump list is derived from a query string parameter. This should be a unique key value to differentiate from other pages. For example, in case a book were pinned, the query string parameter might use the ISBN number for a key.

NAVIGATE BY ATTRIBUTE OF A PAGE

The next method in this blog will have the jump list friendly name display a key value that is embedded in the page. Using the example of a book again, we might realize that few people memorize ISBN numbers, so we instead want to display the name of the book. This name is part of the text within the document, and will be extracted from the page by Element ID.

NAVIGATE  BY POST

The final method discussed is not being presented with code for this blog. It realizes that some people may want to refer back to common searches that they perform. In this case, you will want to enable searching by post and by query string, as the jump list is based on query string. This will get the parameters during the post, and the web site author will have to use some imagination to find a friendly name to display in the jump list. I might include code for this in a later blog, but before writing the code, take a moment to evaluate alternatives. It might best be achieved by providing a static jump list to the search page, and have the search page itself offer links to recent searches. As there is a finite number of items in a jump list, the developer will want to maximize use of the entries for the best user experience. It would be easy to clutter the jump list with search history that could be useless if the user does not know what the searches represent, as seen by the title.

DEVELOPER: GIVE ME THE CODE!

The set of code below is an example of how to pin to the taskbar, as well as pin to the Windows 8 start screen tile. Although the purpose of this blog is to pin to the taskbar, with just a few extra lines of code, you can have a nice Start Screen Tile.

To understand the code, you should follow along this article according to the first version as the MRU is associated to the query string, and then the refactored code as the MRU is associated to the textual value of an element in the page. By following along, it is hoped to quickly teach the basics of pinning. Attached to this article is all the demo code in a VSTS solution, as many will learn faster by just taking the code directly from a working project. 

META TAGS AND XML

The meta tags below apply to the home page, or the page that is used to pin the site. I am including additional tags for pinning to the Start Screen Tile for IE 9/10 versus IE 11. The XML file could alternatively be implemented as meta tags, but the choice of an external file is due to the fact that it is cached static content.

Site home page, to be pinned. This is within the header section.

<meta http-equiv="X-UA-Compatible" content="IE=edge" />
 <meta name="msapplication-config" content="/BrowserConfig.xml" />
 <meta name="application-name" content="My Application Pin Demo" />
 <meta name="msapplication-tooltip" content="MyApplication Web Pages" />
 <meta name="msapplication-starturl" content="/Home.aspx" />
 <meta content="name=Search for Exams;
 action-uri=/ExamSearch.aspx;
 icon-uri=/Static/Images/MyApplication-SiteIcon.ico;
 window-type=self"
 name="msapplication-task" />
 
 <meta name="msapplication-TileImage" content="/Static/Images/MyApplication-Square.png" />
 

browserconfig.xml

<?xml version="1.0" encoding="utf-8"?>
 <browserconfig>
 <msapplication>
 <tile>
 <square70x70logo src="https://blogs.msdn.com/Static/Images/MyApplication-Tiny$.png"/>
 <square150x150logo src="https://blogs.msdn.com/Static/Images/MyApplication-Square$.png"/>
 <wide310x150logo src="https://blogs.msdn.com/Static/Images/MyApplication-Wide$.png"/>
 <square310x310logo src="https://blogs.msdn.com/Static/Images/MyApplication-Large$.png"/>
 <TileColor>#ffc533</TileColor>
 </tile>
 </msapplication>
 </browserconfig>

JAVASCRIPT

The include JavaScript is intended to be a simple method that is in an external file called "MyApplicationJSLibrary.js". There are some parameters that are coded internal to the function which you could expose if it were necessary to be configurable. For example, the WindowType attribute given below as "Self" could be "tab" or "window", or a parameter so that it could vary by page (see references section for link to documentation of this method). In this example, I am simplifying it so that only the minimum parameters need to be sent.

If you were to include this functionality for all pages, the jump list might be less predictable to the user, as there is a limited number of links by default. Notice that application specific logic is in the JavaScript, to represent the ExamId as well as other application specific text. This is generally a bad practice, if one were making a reusable library function to share with the developer community. However, we are assuming that in your web site, you are implementing "Most Recently Used" functionality for a limited number of pages, possibly even just one page in the entire web site.

// FILENAME: MyApplicationJsLibrary.js
 function MyApplicationJsLibrary() {
 /// <summary>MyApplicationJsLibrary is methods for pinning to the taskbar, such as for jump lists.</summary>
 this.pinExam = function (jumpListTitle) {
 /// <summary>pinExam will add the current Exam.aspx page to the jump list of the task bar, referenced by Exam number.</summary>
 /// <param name="jumpListTitle" type="String">Optional. Entry title that is displayed in the Jump List. If not provided, jumpListTitle will be derived from the query string parameter.</param>
 try {
 if (window.external.msIsSiteMode()) {
 var webUrl = window.location.href;
 var friendlyTitle;
 var webPage = window.external;
 if (jumpListTitle == undefined) {
 friendlyTitle = "ExamID " + getQuerystringNameValue(webUrl, 'ExamId');
 }
 else {
 friendlyTitle = jumpListTitle;
 }
 webPage.msSiteModeCreateJumpList("My Recent Exams");
 webPage.msSiteModeAddJumpListItem(
 friendlyTitle, webUrl, "/Static/Images/MyApplication-SiteIcon.ico", "self");
 }
 }
 catch (ex) {
 }
 }
 
 //PRIVATE METHODS (helper functions)
 function getQuerystringNameValue(webUrl, parameterName) {
 /// <summary>Get parameter from a url, which assumes querystring objects are name=value pairs, this will not work if querystring parameter is of format having just parameter name.</summary>
 /// <param name="webUrl" type="String">Full Web URL, including querystring.</param>
 /// <param name="parameterName" type="String">Querystring parameter name to extract value from.</param>
 /// <returns type="String" />
 var queryStringArray = webUrl.split("?");
 var queryStringParamArray = queryStringArray[1].split("&");
 var nameValue = null;
 
 for (var iParamIndex = 0; iParamIndex < queryStringParamArray.length; iParamIndex++) {
 queryStringNameValueArray = queryStringParamArray[iParamIndex].split("=");
 if (parameterName == queryStringNameValueArray[0]) {
 nameValue = queryStringNameValueArray[1];
 }
 }
 return nameValue;
 }
 }
 

JQUERY

There are several methods to pin the page to the taskbar using JavaScript. My preference is to use the JavaScript library JQuery. The code attached to this post uses JQuery as referenced from the CDN, which is best for caching instead of publishing your local version of JQuery. The simplest approach would be immediately executing JavaScript code, which is a bad practice that should always be avoided, especially whenever code accesses DOM elements. A better approach is to ensure that the page has loaded, then execute the function. An example of this would be as follows, to embed code example into the header of the web page that you wish to implement MRU for:

<script type="text/javascript" src="https://ajax.aspnetcdn.com/ajax/jQuery/jquery-2.0.3.min.js"></script>
 <script src="https://blogs.msdn.com/Static/JS/MyApplicationJsLibrary.js"></script>
 <script>
 $(document).ready(function () {
 var pin = new MyApplicationJsLibrary();
 pin.pinExam();
 })
 </script>
 

IMAGES

We want images for icons to appear by your browser address bar, history, pinned task bar, and jump lists. We also want images for the Start Screen Tile. The table of image sizes below apply to features as described in this post, as a recommended first draft during development. As you are developing the site, you will be testing images repeatedly, experimenting first with the images at 80% size, then 100%. The .png files could be other image types, but I favor this format for purposes of this post. If the cache seems to interfere with the development, a link to another person's blog about how to clear the cache is provided in the references section at the end of this post. For implementing MRU functionality, all you really need is the .ico file, and to take it further to implement start screen tile, the .png files are necessary.

To see what we are trying to accomplish with the icon images, the screen grabs below which were taken by right clicking the pinned site from the taskbar and by viewing the page in a browser window. The icons should be tested at all locations in the jump list, and all locations in the browser. I have observed times when the image looks great in the taskbar, but blurry in the address bar, or vice versa. It is also possible to use different icon files for different places, as referenced by the meta tags, in case you really need to optimize the images.

As you are developing the site, you may need several iterations of testing the icon images, where the differences may be subtle. If it appears that your changes are either not being accepted, or are too subtle to detect a difference, I use two approaches. The first approach is to have an icon handy that is radically different from the published icon, and temporarily load that in your browser before publishing the new image. This will verify that there was a difference. Sometimes though, you might not be getting refreshed icons loaded, so clear the browser cache (Tools, Delete Browsing History...).

The browser will represent the icon images at the top of the page as seen below.

The secondary (optional) part of this article has to do with images for the Start Screen Tile, which is implemented by the .png files and not the .ico files detailed above. Depending on your system, you might see two possible sizes, Small and Medium, or 4 possible sizes, Small, Medium, Wide, Large. IE11 supports the 4 sizes, as rendered by the browserconfig.xml, and for IE9/10, only 2 sizes are supported, as rendered by the misapplication-TileImage meta tag.

Much like for icon images, the .png images used for the Start Screen Tiles will need to be tested and very likely refactored. In the course of development, the images will need to have their cache cleared, which is not the same cache as in the normal browser. To clear the cache, open the browser from the desktop, and hit the Windows-C keys to display the charms bar for the browser, and choose the Settings as it applies to Internet Explorer. Choose Options and then select the History to select browsing data that you want to delete. In the History taskbar, delete cached images, cookies and browsing history and hit the delete button.

Troubleshooting can be sometimes difficult, but some known issues are mentioned here.

• If your site expects the 4 sizes, yet you do not see all of them, it could be caused by incorrect size of the images. For example, if the large (square310x310logo) image is only 120x120 pixels, it will not be available, and you will see only 3 images.
• If your site expects the 4 sizes, but only see 2 of them, verify that the link to the browserconfig.xml file is correct. The site will still function, but failure to find the browserconfig.xml file will result in implementing the deprecated IE10 meta tag, which supports only two sizes.

Image size table.

Developer: Rework to support user friendly lists

Now that we understand the basic concepts, we might want to enhance the user experience to support MRU list with more friendly names, that are derived from the attributes of a page instead of the query string. Effectively, this can be perceived as the difference between users access by key name instead of key value. To do this, the following code changes would have to be done for the JavaScript function in the .js file, as well as the JQuery code on the page being indexed for MRU.

JavaScript Changes:

The original JavaScript presented above already supports user friendly lists, as the method pinExam effectively acts as an overloaded function by having logic to determine if the parameter jumpListTitle is provided or not. To ensure your code is as lightweight as possible, it is suggested that you remove the condition and implement the parameter or not, depending on your needs. As a reminder, your site is not using this code as a reusable library, rather a specific implementation of MRU list, so please take the code and tweak it according to your specific needs, removing any dead code.

JQuery Changes:

Assuming there is a form element whose ID is txtExamTitle, simply modifying the previously provided call to pinExam as below will implement the necessary change to pin by friendly name. Here, it is important to realize that this code would not work unless the entire DOM was loaded, so that the value for txtExamTitle is derived from the query string. Also, realize that this is behind the scenes logic that happens at time of page load, if it were necessary to pin to a title derived from user entry, the logic would have to be changed.

pin.pinExam($("#txtExamTitle").val());

Sometimes, in ASP.NET, the clientID is not always predictable, so you could remove the client side derivation of the value to server side, as per <%=txtExamTitle.Text%>. Do yourself a favor, and make it predictable without having to resort to server side code embedded in your JavaScript and/or JQuery code. An ASP.NET textbox control could have the attribute ClientIDMode="Static" set to help if this were an issue.

Final View:

After some simple refactoring of the code, and using the friendly name of the title of the exams being displayed, we see the equivalent MRU jump list represented as below. Notice that the text of the titles exceeds the boundaries of the container. This minor issue is mitigated by users being able to hover over the jump list to see the full text of the title.

SPECIAL CONSIDERATIONS

In case of pinning to pages that require active sessions, or redirection after required login, you will have to alter your web page design, or else have pinning of limited value.

REFERENCES

A few useful links that I use for pinning web sites and for authoring this blog post.

Pinned sites for the desktop. MSDN documentation, a must read.

msSiteModeAddJumpListItem method. MSDN documentation on MRU part of the code.

X-Icon Editor.  I use this site to convert the source .png files to an .ico file, such as for favicon.ico.

How to Clear Cache in Windows 8 Step by Step. Changing image references while developing sometimes shows old code. Clear the cache if you see unexpected results.

How to: Create JavaScript XML Documentation Comments. Always document your code! Some simple tips to enable IntelliSense.

CONCLUSION

This explains how to implement "Most Recently Used" functionality in your web sites. This blog post is designed to get you quickly up to speed on the basic concepts, with working code. This covers Windows 8 static tiles, and pinning to the task bar using IE 9,10, and 11.

A lot of functionality was covered, including pin to taskbar, static jump lists, dynamic jump lists, most recently used web pages, start screen tiles, and searching for web site locally as if it were a windows store application.

PinToTaskbar.zip

1. What are snippets?
2. Overview
3. Configuration
4. How to use snippets
5. How to create snippets
6. Example Snippet - Find tables using Sequences

WHAT ARE SNIPPETS?

SQL Server Code Snippets are what they sound like - they are snippets of code that may be accessed easily through a program such as SQL Server Management Studio or Visual Studio Team System. For the purposes of this article, we are focussing on using them in SQL Server Management Studio, in the 2012 edition.

OVERVIEW:

In my team, we use SQL Code Snippets in SQL Server 2012 to save time for authoring queries that may be reused many times in our development cycle. This post is to detail how to use Snippets in SQL 2012, and a simple means to share the snippets among the team. We gain a lot of productivity by sharing our snippets through a source control product, TFS (Team Foundation Server), and retrieving through VSTS (Visual Studio Team System) to a local hard drive. This provides a very simple procedure to share snippets across the team as well as the normal benefits of a source control product.

In my experience, I've used Insert Snippets and Surrounds With Snippets. I favor Insert Snippets whenever possible. You can still get the benefits of highlighting text that should be modified with Insert Snippets, the only practical difference is that you type your changes after you implement an Insert Snippet, and you type your changes before you implement a Surrounds With Snippet. This is definitely a personal opinion, so I encourage you to try both. I lean towards one or the other because if you have a large library of snippets, and hopefully you chose to arrange them in hierarchical folders, it can be difficult to remember if you need to navigate one way or the other.

In the example given later in this article, I will create an Insert Snippet that helps identify tables in your database which implement Sequences. Parameters given include SchemaName, TableName, and ColumnName. These parameters will act as filters, and only the Schema Name is required. For more practical information on SQL Server Sequences, please refer to my earlier blog post. https://blogs.msdn.com/b/kenobonn/archive/2013/05/14/sql-server-2012-sequences-in-vsts-projects.aspx

We have two main hierarchies of user defined snippets. One is project specific, another is SQL specific. The project specific node has subnodes for features of the project, and can also be arranged by developer code versus troubleshooting code, where you may consider test and production support as users who may benefit as well. The SQL specific node is mainly for SQL tricks or common code that you may run in development or production. The root node of my Snippet library begins with a period, to place it at the top, alphabetically, as this is the most common set of snippets that I use. 

CONFIGURATION:

Assumption is that SQL Server 2012 Client Tools are installed, and Visual Studio (2008 or above) with Team features to integrate with a TFS project.

1. First, make a note of the location in TFS Source Control Explorer where the SQL Snippets are stored. See Figure 1 below.
1. Write down the Local Path that maps to the root of the Snippets directory.
2. In the example below, the location is “C:\tfs\Tools\Team Standards\.Snippets”.
2. In SQL Server Management Studio (SSMS), go to "Tools", "Code Snippets Manager...". See Figure 2 below.
3. Add a reference to the directory where Snippets from TFS are located. See Figures 3 and 4 below.
4. In Visual Studio 2010, bring up the Code Snippets Manager by using the keys CTRL-K, CTRL-B (while holding down the CTRL key, press the K then the B keys). Change the language to SQL, and Add the directory for code snippets as identified earlier in step 1 b.

FIGURE 1: VSTS Source Control Mapping

FIGURE 2: Code Snippets Manager in SSMS - menu

FIGURE 3: Code Snippets Manager in SSMS – Add new directory

FIGURE 4: Mapping SSMS Snippets to local hard drive

HOW TO USE SQL SNIPPETS
To use SQL 2012 snippets, there are two kinds of snippets, Insert and Surrounds With.

1. For Insert, simply right click in query window, choose "Insert snippet..." and navigate the hierarchy of folders to the snippet of interest. See Figure 5 for an example of an Insert Snippet.
2. For Surrounds with, type a value or SQL statement and select it, so that it is the focus of the query window. Right click in the query window, and choose “Surround with…”.  See Figure 6 for an example of a Surrounds With snippet.

FIGURE 5: How to use an Insert snippet

FIGURE 6: How to use a Surrounds With snippet

HOW TO CREATE SQL SNIPPETS

Templates for creating SQL Snippets are stored in the Snippets root directory. Included below are the templates for Insert and Surrouds With snippets. To create a new snippet, edit the template of interest by opening the file in Visual Studio. Store the changes in the appropriate directory, and save to source control. See the References section for help in creating snippets.

 
INSERT SNIPPET TEMPLATE
For an Insert Snippet, use the template below and modify the Title, Description, Author, and the code within the CDATA section below. The Title is what the user will click to select the snippet, the Description is hover text to help the user understand the purpose of the snippet. There may be zero or many Literals within the Declarations element. A Literal is something that will be used in substition in the resultant code, and is referenced by its name surrounded by $ symbols.

<?xml version="1.0" encoding="utf-8" ?>
 <CodeSnippets xmlns="https://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
 <CodeSnippet Format="1.0.0">
 <Header>
 <Title>Template - Insert</Title>
 <Description>Demo for Insert Code Snippet.</Description>
 <Author> Ken O. Bonn </Author>
 <SnippetTypes>
 <SnippetType>Expansion</SnippetType>
 </SnippetTypes>
 </Header>
 <Snippet>
 <Declarations>
 <Literal>
 <ID>DatabaseName</ID>
 <ToolTip>Name of database.</ToolTip>
 <Default></Default>
 </Literal>
 </Declarations>
 <Code Language="SQL">
 <![CDATA[
 ------------------------------------------------------
 -- FILENAME: Template-Expansion.snippet
 -- PURPOSE: Template for Expansion (Insert) snippets.
 -- AUTHOR: Ken O. Bonn
 -- DATE: May 15, 2013
 ------------------------------------------------------
 SET NOCOUNT ON;
 
 EXEC SP_HELPDB $DatabaseName$;
 
 ]]>
 </Code>
 </Snippet>
 </CodeSnippet>
 </CodeSnippets>
 

SURROUNDS WITH SNIPPET TEMPLATE 

 The MSDN documentation has a nice example of a Surrounds With Snippet that you can use as a template. As I do not favor these snippets, I will refer to the link below in case you wish to create a Surrounds With snippet.

https://msdn.microsoft.com/en-us/library/gg492130.aspx

EXAMPLE - FIND TABLES USING SEQUENCES FOR DEFAULT VALUES

Copy and paste the code below into a directory that you configured for Code Snippets. Afterwards, follow the procedures that I detailed for calling an Insert Snippet. If you don't have a Sequence in your database, you may want to do the exercises in my earlier article, at https://blogs.msdn.com/b/kenobonn/archive/2013/05/14/sql-server-2012-sequences-in-vsts-projects.aspx

<?xml version="1.0" encoding="utf-8" ?>
 <CodeSnippets xmlns="https://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
 <CodeSnippet Format="1.0.0">
 <Header>
 <Title>Columns using Sequences</Title>
 <Description>Find Columns that use Sequences as default values.</Description>
 <Author> Ken O. Bonn </Author>
 <SnippetTypes>
 <SnippetType>Expansion</SnippetType>
 </SnippetTypes>
 </Header>
 <Snippet>
 <Declarations>
 <Literal>
 <ID>SchemaName</ID>
 <ToolTip>Schema Name to find Sequence. Required.</ToolTip>
 <Default>dbo</Default>
 </Literal>
 <Literal>
 <ID>TableName</ID>
 <ToolTip>Table Name to find Sequence. Optional.</ToolTip>
 <Default></Default>
 </Literal>
 <Literal>
 <ID>ColumnName</ID>
 <ToolTip>Column Name to find Sequence. Optional.</ToolTip>
 <Default></Default>
 </Literal>
 </Declarations>
 <Code Language="SQL">
 <![CDATA[
 ---------------------------------------------------------------------
 -- FILENAME: ColumnsUsingSequences.snippet
 -- PURPOSE: Find tables having columns that implement Sequences.
 -- AUTHOR: Ken O. Bonn
 -- DATE: January 24, 2013
 ---------------------------------------------------------------------
 SET NOCOUNT ON;
 
 DECLARE @SchemaName sysname
 , @TableName sysname
 , @ColumnName sysname;
 SET @SchemaName = '$SchemaName$';
 SET @TableName = '$TableName$';
 SET @ColumnName = '$ColumnName$';
 
 SELECT
 [Schema Name] = scc.[name]
 , [Table Name] = so.[name]
 , [Column Name] = sc.[name]
 , [Constraint Name] = dc.[name]
 , [Sequence Name] = LTRIM(REPLACE(SUBSTRING(dc.[definition],
 CHARINDEX(dc.[definition], 'NEXT VALUE FOR') + 16, 100
 ), ')', ''))
 , [Sequence Object ID] = OBJECT_ID(LTRIM(REPLACE(SUBSTRING(dc.[definition],
 CHARINDEX(dc.[definition], 'NEXT VALUE FOR') + 16, 100
 ), ')', '')))
 FROM sys.schemas scc
 INNER JOIN sys.objects so
 ON scc.[schema_id] = so.[schema_id]
 INNER JOIN sys.columns sc
 ON so.[object_id] = sc.[object_id]
 INNER JOIN sys.default_constraints dc
 ON so.object_id = dc.parent_object_id
 AND sc.[object_id] = dc.parent_object_id
 AND sc.column_id = dc.parent_column_id
 WHERE dc.[type] = 'D'
 AND dc.[definition] LIKE '%NEXT VALUE FOR%'
 AND (scc.[name] = @SchemaName OR RTRIM(@SchemaName) = '')
 AND (so.[name] = @TableName OR RTRIM(@TableName) = '')
 AND (sc.[name] = @ColumnName OR RTRIM(@ColumnName) = '')
 ORDER BY scc.[name], so.[name], sc.[name];
 ]]>
 </Code>
 </Snippet>
 </CodeSnippet>
 </CodeSnippets>

In this example, we are implementing a primary key using a Sequence as the key generator instead of Identity. As a Sequence does not generate a value for Scope_Identity, I will demonstrate an alternate technique to retrieve the value of the newly inserted key from the output clause of an insert statement, as saved to a temporary table variable.

There are plenty more scenarios to implement Sequences, such as having a unique key distributed among multiple tables. Performance improvements for large volume of inserts are a great use for Sequences. It would be a lengthy discussion to consider when to use Sequences and when not to, so I will defer that topic. I encourage readers to research on the appropriate cache size for their circumstances, I chose 1000 in the example, but that may be a bit large for most needs. Sequences are one of many reasons to upgrade to SQL Server 2012.

1. Ensure that Visual Studio 2010 supports the latest SQL Server 2012 projects.

Install SQL Server Data Tools (SSDT). A quick Bing search for SSDT should find it for you, but current location is at https://msdn.microsoft.com/en-us/data/tools.aspx

2. Create a SQL Server Project (having extension .sqlproj, not the former .dbproj).

See figures 1 and 2. After project creation, go to the properties of the project and ensure that the Target platform is "SQL Server 2012".

3. Create a sequence.

Use VSTS to import the file into the proper location. By following this method, the folder structure will automatically create the file in the proper folder.

• Create it as a file, outside of the project, with the Sequence create definition See below for an example.
• Right click the project, and choose Import, then Script, and specify the newly created script file.
• Go to the Specify Options section, and ensure correct Folder Structure is specified. My preference is for "Schema\Object Type".

Code below is a simple sequence.

CREATE SEQUENCE dbo.SeqDemoTable1
 AS int
 START WITH 1
 INCREMENT BY 1
 MINVALUE 1
 NO MAXVALUE
 NO CYCLE
 CACHE 1000

4. Associate the Sequence to a table as a default rule.

Code below will create the table and associate the primary key with the Sequence.

CREATE TABLE dbo.DemoTable1
 (
 Field1ID int NOT NULL CONSTRAINT df_DemoTable1_Field1ID DEFAULT NEXT VALUE FOR dbo.SeqDemoTable1,
 Field2 varchar(10) NULL,
 Field3 varchar(10) NULL
 )
 GO
 ALTER TABLE dbo.DemoTable1
 ADD CONSTRAINT PK_DemoTable1_Field1ID PRIMARY KEY CLUSTERED 
 (
 Field1ID ASC
 )

 5. Insert to a table and verify Sequence values unique and get latest value inserted.

-- Cannot use scope_identity for Sequences.
 -- Instead, trap the Primary Key (Sequence) into a table.
 DECLARE @DemoTable1 table (Field1ID int) 
 DECLARE @LatestInsertKey int
 --Insert two records in a single statement
 INSERT INTO dbo.DemoTable1(Field2, Field3)
 OUTPUT INSERTED.Field1ID INTO @DemoTable1 
 VALUES
 ('ABC','DEF')
 , ('GHI','JKL')
 -- Get latest value if multiple inserts.
 --If single insert can be assumed, not required to use MAX function.
 SELECT @LatestInsertKey = MAX(Field1ID) FROM @DemoTable1
 -- Verify results for Latest Insert Key
 SELECT @LatestInsertKey AS [@LatestInsertKey]
 -- Verify results for Sequence generation
 SELECT * FROM dbo.DemoTable1

FIGURE 1 - PROJECT CREATION

FIGURE 2 - PROJECT PROPERTIES

FIGURE 3 - IMPORT SQL SCRIPT TO PROJECT

FIGURE 4 -  PROJECT STRUCTURE

Work Items:

For the direct URL, specify {TSWA_URL}/wi.aspx?id={0} where {0} represents a single work item ID to edit. In TFS 2010 Beta 1, additional parameters such as pcname (project collection name), pname (project name), and tfs (tfs connection) may be specified to ensure work item selected from proper repository.

Queries:

To query for a bug by ID, use WIQL to search for ID and specify output columns. The URL will appear as: {TSWA_URL}/q.aspx?wiql=SELECT%20ID,Title,State%20FROM%20WorkItems%20WHERE%20ID%20IN({0}) where {0} represents a comma delimited list of work item IDs to view. In TFS 2010 Beta 1, additional parameters mentioned above may be specified as well.

Location of {TSWA_URL}:

Using TSWA 2008, the base url is typically the same as the connection to the TFS connection, except you specify port 8090 instead of 8080 (assuming default installations). In TFS 2010 Beta 1, TSWA is tied closer to TFS, and the base url is the same port under a virtual directory called “web”. It is important to remember that TFS 2010 supports multiple collections of projects, whereas TFS 2008 does not have the concept of collections, so all projects are in one hierarchy.

To illustrate the differences, the table below assumes you wish to edit work item 123, or query for work items 123 and 456. Querystring parameters are in orange highlighting to help understand the available parameters.

I haven’t yet found official documentation on parameters available for direct links in TSWA 2008 or 2010, yet the links below may be handy. Some of them may be outdated yet useful regardless.

TSWA tip: How to use the new TSWA template URL feature (initial value URL)

https://blogs.msdn.com/buckh/comments/8506227.aspx

Using Team System Web Access

https://msdn.microsoft.com/en-us/library/bb822087.aspx

Updates to Team System Web Access

https://blogs.msdn.com/bharry/archive/2008/04/15/updates-to-team-system-web-access.aspx

How to: Add New Work Items (Team System Web Access)

https://msdn.microsoft.com/en-us/library/bb822136.aspx

Team System Web Access 2008 Power Tool is now available

https://blogs.msdn.com/buckh/archive/2007/11/29/team-system-web-access-2008-power-tool-is-now-available.aspx

Please see my article at https://msdn.microsoft.com/en-us/library/dd637842.aspx

The PIVOT function in SQL Server is not used very often in projects I work on, but can be extremely useful for specific kinds of pages, especially when consumed in ASP.NET using GridView objects. Some people struggle with PIVOT on one field, the online documentation should be sufficient for that need. Here is an example of pivoting on two fields for the SQL community. Having a need to show multiple properties for an entity is a good case for such.

To demonstrate this technique, I will create some contrived data, and show pivoting on it. Note that you must pivot on an aggregate function, which may or may not be relevant, such as the case where you want to pivot on a text field. We will use a table of pets with their owners, and another table containing properties of the pets, and show a report for properties of them, such as name, breed and gender. To make this demo even more contrived, we will assume no more than 3 pets per owner (I'm demonstrating the technique, you need to fit it into your requirements).

Below is a script to create two relational tables, Pet and PetDetail. Note, the database schema would likely need a more generic animal table if this were a real application, and we would display the owner names, not their ID's. It may seem obvious that the data model should be optimized, but remember this is a demo of a SQL skill, it is not a demo for data modelling. The insert statements use a syntax new to SQL Server 2008.

The data in the @Pet table has records representing distinct Pets. This has a one to many relationship to the @PetDetail table. Further complicating this is the fields DetailType and DetailValue are effectively key / value pairs. Thus, we have a model with a parent record having multiple key / value pairs. For our report, we only care about data pertaining to the Gender and Breed keys (DetailType).

SQL 2008 -Data Creation - Pivot Demo

Copy Code

--SQL to create tables and insert data here...
DECLARE @Pet Table
(
  PetID INT
, OwnerID INT --FK to fictitious PetOwner table
, PetName NVARCHAR(50)
, AnimalType NVARCHAR(10)
)
DECLARE @PetDetail Table
(
  PetDetailID INT
, PetID INT -- FK to @Pet table
, DetailType NVARCHAR(50)
, DetailValue NVARCHAR(50)
)
INSERT INTO @Pet(PetID, OwnerID, PetName, AnimalType) VALUES
  (1, 1, 'Sonya', 'Dog')
, (2, 2, 'Bessy', 'Cat')
, (3, 2, 'Speedy', 'Cat')
, (4, 3, 'Nema', 'Cat')
, (5, 3, 'Milo', 'Cat')
, (6, 3, 'Naala', 'Cat')
INSERT INTO @PetDetail(PetDetailID, PetID, DetailType, DetailValue) VALUES
  (1, 1, 'Breed', 'Norwegian Samoyed')
, (2, 1, 'Gender', 'F')
, (3, 2, 'Breed', 'Holstein Hybrid')
, (4, 2, 'Gender', 'F')
, (5, 3, 'Breed', 'DSH')
, (6, 3, 'Gender', 'F')
, (7, 4, 'Breed', 'Manx')
, (8, 4, 'Gender', 'M')
, (9, 5, 'Breed', 'DSH')
, (10, 5, 'Gender', 'F')
, (11, 6, 'Breed', 'Lynx-Point Siamese')
, (12, 6, 'Gender', 'F')

SELECT PetID, OwnerID, PetName, AnimalType FROM @Pet ORDER BY PetID
SELECT PetDetailID, PetID, DetailType, DetailValue FROM @PetDetail ORDER BY PetDetailID

This data may be easier to visualize graphically as below:

Note: The remaining queries below assume data generated as per the insert statements above.

A typical query would give accurate data as below, however would lead to multiple records per pet owner. This would require looping or other logic in the front end to translate to a nice report of each owner and their pets. To gain a better understanding of Ranking Functions , experiment with the RANK function as in the commented out code below, and compare to the DENSE_RANK function. This will show why this report requires the DENSE_RANK function in order to be usable by the PIVOT function in the subsequent example.

SQL 2008 -Simple Joins - Pivot Demo

Copy Code

--Simple Join SQL HERE...
SELECT p.OwnerID, p.PetName, p.AnimalType
, pd.DetailType, pd.DetailValue
,DENSE_RANK() OVER (PARTITION BY p.OwnerID ORDER BY p.PetName ASC) AS [Pet#]
--,RANK() OVER (PARTITION BY p.OwnerID ORDER BY p.PetName ASC) AS [Pet# by RANK]
FROM @Pet p
INNER JOIN @PetDetail pd ON p.PetID = pd.PetID
ORDER BY p.OwnerID, p.PetName, pd.DetailType

Now, on to the report using the PIVOT function. To understand what's going on, the DENSE_RANK function affords us the ability to distinguish key fields sequentially so that we can pivot on them using predictable names. The predictable names will be the key name plus 1, 2, or 3.

Observe how there are two pivots in this query. The first one pivots from the concatenation of the key name as described above. This is necessary so we can differentiate the data belonging to that key. However, the second pivot is at a higher level, for the distinct pet. Since we don't need to distinguish one value from the other, because the PetName will be the same for each record, we simply generate a pivot based on an arbitrary string value concatenated with the DENSE_RANK value.

Also observe the use of the GROUP clause. Here, I want to group by the OwnerID to create a unique record by owner, however the PetName field is removed from the grouping because we are pivoting on it. For further explanation of the PIVOT function, see the online documentation at https://msdn.microsoft.com/en-us/library/ms177410(SQL.90).aspx

SQL 2008 -PIVOT Function - Pivot Demo

Copy Code

--PIVOT QUERY HERE...
SELECT
OwnerID
, AnimalType
, Pet1Name = MAX([PetName1])
, Pet1Gender = MAX([Gender1])
, Pet1Breed = MAX([Breed1])
, Pet2Name = MAX([PetName2])
, Pet2Gender = MAX([Gender2])
, Pet2Breed = MAX([Breed2])
, Pet3Name = MAX([PetName3])
, Pet3Gender = MAX([Gender3])
, Pet3Breed = MAX([Breed3])
FROM (
SELECT
      p.OwnerID
      , p.PetName
      , p.AnimalType
      , pd.DetailType
      , pd.DetailValue
      ,pd.DetailType + CAST(DENSE_RANK() OVER (PARTITION BY p.OwnerID ORDER BY p.PetName ASC) AS NVARCHAR) AS [PetNumber]
      ,'PetName' + CAST(DENSE_RANK() OVER (PARTITION BY p.OwnerID ORDER BY p.PetName ASC) AS NVARCHAR) AS [PetNamePivot]
FROM @Pet p
INNER JOIN @PetDetail pd ON p.PetID = pd.PetID
) AS query
PIVOT (MAX(DetailValue)
      FOR PetNumber IN ([Gender1],[Gender2],[Gender3], [Breed1], [Breed2], [Breed3])) AS Pivot1
PIVOT (MAX(PetName)
      FOR PetNamePivot IN ([PetName1],[PetName2],[PetName3])) AS Pivot2
GROUP BY
  OwnerID
, AnimalType
ORDER BY OwnerID

Concluding Remarks

The PIVOT function is a powerful tool for transforming data into simplified structures. It may seem difficult at first to grasp what is being pivoted, and how to do so. Hopefully the example above will bring clarity for pivoting on two or more fields. It should be considered whether to transform the data in SQL Server or the client, as there are tradeoffs to each approach. The PIVOT function would likely have a performance impact on the query based on complexity of the pivot and / or the size of the data being transformed. This performance impact may be less than you might imagine if appropriate filters are applied. At any rate, performance testing would be critical, whether you use the PIVOT function or implement equivalent functionality in the business layer. A well constructed PIVOT statement could lessen the chances of downstream bugs, as the code required to pivot outside of SQL could be very complex, especially if NULLs are allowed in the key fields.

However, this potential for performance impact could be offset by simplifying the code and processing at the client layer, as doing such a transformation in your favorite programming language could be very complex and have just as much of a performance impact. By pivoting in the SQL layer, databinding to a GridView object can be done very straightforward, whereas the alternative would require transformations in the code prior to the databinding event, or hijack the onrowdatabound or other events to do secondary processing.

Regardless of the approach taken for PIVOT, whether it be in SQL Server or programmatically in a .NET language, testing is critical. Be sure to do performance testing as well as accuracy of results, and to do so with a wide range of data to ensure the system can handle real data.