{"id":125,"date":"2008-08-30T14:14:00","date_gmt":"2008-08-30T14:14:00","guid":{"rendered":"\/lisa\/post\/2008\/08\/30\/A-bug-IMHO-and-a-workaround-for-conditional-column-export-scenarios.aspx"},"modified":"2008-08-30T14:14:00","modified_gmt":"2008-08-30T14:14:00","slug":"a-bug-imho-and-a-workaround-for-conditional-column-export-scenarios","status":"publish","type":"post","link":"https:\/\/spacefold.com\/lisa\/2008\/08\/30\/a-bug-imho-and-a-workaround-for-conditional-column-export-scenarios\/","title":{"rendered":"A bug, IMHO, and a workaround, for conditional column export scenarios"},"content":{"rendered":"

\nSteve Gavin<\/a> wrote with an interesting question that, at first, I got backwards.\n<\/p>\n

\nHe has a requirement for CSV export output from a report that conditionally hides columns, and he couldn't get the output the way he wanted it to be.  I immediately thought, "That makes sense, somehow the CSV renderer [and as it turns out, the XML renderer] don't know anything about "visibility" logic, just as they couldn't overlay two items, so all the column data is always showing up."\n<\/p>\n

\nWell, no.  The "backwards" part is that none<\/em> of the conditionally hidden data is showing up.  After testing, here is my assessment:\n<\/p>\n

\n

\n\tIf a column has its Hidden property set to any expression, even as innocent an expression as =False<\/strong> (I kid you not, that explicit expression meaning "don't hide" will still do it), that column and its values will not display in CSV or XML output.\n\t<\/p>\n<\/blockquote>\n

\nI guess somebody at Microsoft will say this is a security feature. If it's possible at all that something should be hidden, then never-ever-ever display it in a data export, no matter what?\n<\/p>\n

\nCome on.\n<\/p>\n

So what's the workaround?<\/h4>\n

\nUsually I remind you that you're not stuck with the output Reporting Services hands you, that the XML data export plus XSLT provides a wonderful way to format the report data any way you want.  In this case, the XML output has some significant infelicities so we need to do a little more work, but not much.\n<\/p>\n

\nCreate a second report exactly like the first, with no Hidden expressions.  It's easy to parse the RDL to remove them, whether you do it with the DOM or XSLT.  In XSLT, you might take any identity transform and make a simple change to strip Visibility elements, like this:\n<\/p>\n

\n<<\/font><\/span>?xml version="1.0"?<\/font><\/span>><\/span>
\n<<\/span><\/font>xsl:stylesheet <\/font><\/span>version=<\/font><\/span>"1.0"<\/font><\/span> xmlns:xsl=<\/font><\/span>"http:\/\/www.w3.org\/1999\/XSL\/Transform"<\/font><\/span>><\/span>
\n<\/font><<\/font><\/span>xsl:output <\/font><\/span>encoding=<\/font><\/span>"utf-8"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<<\/span>!– strip Visibility elements from an RDL —<\/font><\/span>><\/span> 
\n<\/font>
\n<\/font>     <<\/font><\/span>xsl:template <\/font><\/span>match=<\/font><\/span>"*"<\/font><\/span>><\/span>
\n<\/font>      <<\/font><\/span>xsl:copy<\/font><\/span>><\/span>
\n<\/font>         <<\/font><\/span>xsl:apply-templates <\/font><\/span>select=<\/font><\/span>"@*"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>         <<\/font><\/span>xsl:value-of <\/font><\/span>select=<\/font><\/span>"text()"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>         <<\/font><\/span>xsl:apply-templates <\/font><\/span>select=<\/font><\/span>".\/*[local-name() != 'Visibility']"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>      <<\/font><\/span>\/xsl:copy<\/font><\/span>><\/span>
\n<\/font>   <<\/font><\/span>\/xsl:template<\/font><\/span>><\/span><\/p>\n

<\/font>    <<\/font><\/span>xsl:template <\/font><\/span>match=<\/font><\/span>"@*"<\/font><\/span>><\/span>
\n<\/font>    <<\/font><\/span>xsl:attribute <\/font><\/span>name=<\/font><\/span>"{name()}"<\/font><\/span>><\/span>
\n<\/font>    <<\/font><\/span>xsl:value-of <\/font><\/span>select=<\/font><\/span>"."<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>    <<\/font><\/span>\/xsl:attribute<\/font><\/span>><\/span>
\n<\/font>    <<\/font><\/span>\/xsl:template<\/font><\/span>><\/span>
\n
\n<<\/span><\/font>\/xsl:stylesheet<\/font><\/span>><\/font><\/span>\n<\/p>\n

\n… so now, at runtime, you can request the XML from this second report rather than the "real" report.  Give the XSLT the parameters that you usually give Reporting Services and let the XSLT decide what columns should be rendered to CSV, or a "stripped" version of the XML if you need that, on this run.\n<\/p>\n

\n"Oh, that's going to be hard!", you say?  No it isn't.  \n<\/p>\n

\nFirst, I'm going to give you a full example here.  I'll use Steve's method of parameterizing his report to hide and show columns in my XSLT example, but the thing is trivial enough for you to figure out how your own parameter strategy could be used in something similar. \n<\/p>\n

\nSecond, although you won't be automagically<\/a> applying the XSLT by attaching it to the RDL, you are really better off learning to request the XML and apply the XSLT yourself.  This gives you a chance to apply different XSLT files, at will, for different formatting requirements, and also to apply parameters for dynamic behavior, as we're going to do here.  I won't belabor this point, because I've discussed it elsewhere, so please read https:\/\/spacefold.com\/lisa\/2007\/10\/28\/After-you-learn-to-walk-you-can-run-a-postscript-to-the-QnD-XSLT-walkthrough<\/a>and let's move on.\n<\/p>\n

Important caveat <\/h5>\n

\nI should say that this is all possible assuming you, like Steve, have some programmatic way of accessing ReportServer, such as I've already shown in other posts (url access<\/a> and web service<\/a> styles).  You need this, because we're intervening before the user gets the report results. We're swapping to a different report for the request, we're asking for XML, we're loading the parameters into the XSLT, applying the XSLT to the XML, and providing the result to the user. \n<\/p>\n

\n If you currently rely on Report Manager for your end-user interface, you need to add a custom interface at least for this particular part.\n<\/p>\n

\nOnce you've made this leap, there is so much more possible!\n<\/p>\n

Workaround implementation<\/h4>\n

\nSteve's report offers sufficient complexity and yet a sufficiently general scenario to be a worthwhile example.  Basically, his report contains some fixed columns, which always appear, and some other columns grouped into attribute sets<\/em>.  I think there is a parameter associated with each attribute set, with a string of T's and F's representing the user's choices (or perhaps security settings) for column visibility within that set. \n<\/p>\n

\nI could be wrong; Steve could have only one parameter and the attribute sets are only choose-able by group, not by individual column. In that case the whole problem is a bit simpler, but very similar. \n<\/p>\n

\nI chose to solve the more complex version, because I have no idea what your<\/em> visibility strategy is, and I want you to see that you can stretch this method to do… whatever.  OK?\n<\/p>\n

Scenario<\/h5>\n

\nSo, let's assume that Steve has a report layout that looks something like this (last two columns are Requested_Ship and Requested_Install, respectively):\n<\/p>\n

\n\"\"\n<\/p>\n

\n… and let's assume that he has one parameter for Group1 and another for Group2. \n<\/p>\n

\nIf these two parameters have the values "FT"<\/strong> and "TF"<\/strong>, respectively, for a given report run, you might see a display result that looks like this:\n<\/p>\n

\n \"\"\n<\/p>\n

\n… meanwhile, the XML or CSV result from this run would only have the fixed columns, like this:\n<\/p>\n

\n<<\/font><\/span>?xml version="1.0" encoding="utf-8"?<\/font><\/span>><\/span>
\n<<\/span><\/font>Report
\n  <\/font><\/span>p1:schemaLocation=
\n  <\/font><\/span>"ConditionalExports http:\/\/reportserver?\/ConditionalExports&amp;rs:Format=XML&amp;rc:Schema=True"<\/font><\/span>
\n   Name=<\/font><\/span>"ConditionalExports"<\/font><\/span>
\n   xmlns:p1=<\/font><\/span>"http:\/\/www.w3.org\/2001\/XMLSchema-instance"<\/font><\/span> xmlns=<\/font><\/span>"ConditionalExports"<\/font><\/span>><\/span>
\n<\/font>   <<\/font><\/span>table1<\/font><\/span>><\/span>
\n<\/font>      <<\/font><\/span>Detail_Collection<\/font><\/span>><\/span>
\n<\/font>         <<\/font><\/span>Detail <\/font><\/span>Sales_No=<\/font><\/span>"1-67901846"<\/font><\/span> Order_Quantity=<\/font><\/span>"8"<\/font><\/span> Terms=<\/font><\/span>"NET 30"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>         <<\/font><\/span>Detail <\/font><\/span>Sales_No=<\/font><\/span>"1-65162786"<\/font><\/span> Order_Quantity=<\/font><\/span>"32"<\/font><\/span> Terms=<\/font><\/span>"Special"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>         <<\/font><\/span>Detail <\/font><\/span>Sales_No=<\/font><\/span>"1-67980171"<\/font><\/span> Order_Quantity=<\/font><\/span>"2"<\/font><\/span> Terms=<\/font><\/span>"Trial 45 Days"<\/font><\/span>\/<\/font><\/span>>
\n<\/span><\/font>        <!– … –><\/span>
\n<\/font>       <<\/font><\/span>\/Detail_Collection<\/font><\/span>><\/span>
\n<\/font>   <<\/font><\/span>\/table1<\/font><\/span>><\/span>
\n<<\/span><\/font>\/Report<\/font><\/span>><\/font><\/span>\n<\/p>\n

\n… so now we create our second report, which looks like this, because all columns have lost their Hidden expressions. I'm showing both design and run time here, and I've changed the column color coding just to remind you. The screenshots are a bit truncated on the right side, so you can't see it, but all columns including Requested_Install on the right are present and accounted for, as fixed columns, here: \n<\/p>\n

\n\"\"\n<\/p>\n

\n… and we plan to get our source XML for exporting purposes from this version of the report.  OK?\n<\/p>\n

Conditional columns using XSLT <\/h5>\n

\nLet's start creating an XSLT that will provide separated-value output with column-hiding to match the report's original intent.\n<\/p>\n

\nYou will see below that I'm using a prefix of "sp" in this XSLT file, for a custom element that doesn't belong to XSLT for my own data. To do this (and this part of the implementation is optional, as I explain below), I add a suitable definition of this prefix to the root stylesheet element.  (The location http:\/\/spacefold.com\/xslt<\/a> doesn't really exist, and doesn't need to exist.)  At the top level, I also provide an output method instruction, so that my separated value file is output as text rather than xml or html:\n<\/p>\n

\n   <<\/font><\/span>xsl:stylesheet <\/font><\/span>version=<\/font><\/span>"1.0"<\/font><\/span> xmlns:xsl=<\/font><\/span>"http:\/\/www.w3.org\/1999\/XSL\/Transform"<\/font><\/span> xmlns:sp=<\/font><\/span>"http:\/\/spacefold.com\/xslt"<\/font><\/span>><\/span>
\n<\/font>      <<\/font><\/span>xsl:output <\/font><\/span>omit-xml-declaration=<\/font><\/span>"yes"<\/font><\/span> method=<\/font><\/span>"text"<\/font><\/span>\/<\/font><\/span>><\/font><\/span>\n<\/p>\n

\nLet's say Steve's report parameters are called Group1 and Group2.  Our XSLT will have matching parameters:\n<\/p>\n

\n   <<\/font><\/span>xsl:param <\/font><\/span>name=<\/font><\/span>"Group1"<\/font><\/span> select=<\/font><\/span>"'FT'"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>   <<\/font><\/span>xsl:param <\/font><\/span>name=<\/font><\/span>"Group2"<\/font><\/span> select=<\/font><\/span>"'TF'"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>   <<\/font><\/span>!– more here, as many groups as you have —<\/font><\/span>><\/font><\/span>\n<\/p>\n

\nI'm showing default values here that match my example report run in the screen shot, but obviously each group would have as many characters in the value as there are columns in the group's set of columns, and obviously at runtime you pass the parameter values to the report, with different combinations for each run.\n<\/p>\n

\nIf you look carefully, you'll see single quotation marks (apostrophes) inside the select attribute's value ("'<\/span>FT'<\/span>"<\/span>). This is only necessary for the literal value, so that the xslt processor knows the value is a string; when you pass your string argument into the stylesheet object you don't have to add those extra marks.\n<\/p>\n

\nFor good measure let's add some more parameters to let the user customize the report value separators and delimiters, starting with a default of comma for the separator and nothing for the delimiters:\n<\/p>\n

\n   <<\/font><\/span>xsl:param <\/font><\/span>name=<\/font><\/span>"Separator"<\/font><\/span> select=<\/font><\/span>"','"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>   <<\/font><\/span>xsl:param <\/font><\/span>name=<\/font><\/span>"Delimiter"<\/font><\/span>\/<\/font><\/span>><\/font><\/span>\n<\/p>\n

\nNow let's set up a variable to represent all<\/em> the columns in the report, concatenating all the group parameters togethers and adding the "fixed" columns into the full sequence, wherever they happen to appear in the layout. You can give the "fixed" columns the literal value "T" in this concatenated version, since they always appear in the report. In my example, there's one fixed column at the left of the table, and two more in between the two groups:\n<\/p>\n

\n  <<\/font><\/span>xsl:variable <\/font><\/span>name=<\/font><\/span>"Groups"<\/font><\/span> select=<\/font><\/span>"concat('T',$Group1,'TT',$Group2)"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>   <<\/font><\/span>!– add 'T' in proper position for all columns that aren't parameterized —<\/font><\/span>><\/font><\/span>\n<\/p>\n

\n… and now let's tell the XSLT about the full set of columns.  Here, I'm doing it as a variable which I will refer to later on as a lookup set.  This is the part of the stylesheet that uses my custom namespace (aliased as "sp"):\n<\/p>\n

\n<<\/font><\/span>sp:GroupCols<\/font><\/span>><\/span>
\n<\/font>      <<\/font><\/span>!– the group and sequence information aren't really important,
\n       it's just for clarity in the example, with "Group 0" being fixed columns.
\n        The only important thing is that the full set of columns are represented
\n        in the same order as the concat'd groups above so that the full sequence
\n        of T's and F's matches the column sequence here —<\/font><\/span>><\/span>
\n<\/font>      <<\/font><\/span>col <\/font><\/span>group=<\/font><\/span>"0"<\/font><\/span> sequence=<\/font><\/span>"1"<\/font><\/span> name=<\/font><\/span>"Sales_No"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>      <<\/font><\/span>col <\/font><\/span>group=<\/font><\/span>"1"<\/font><\/span> sequence=<\/font><\/span>"1"<\/font><\/span> name=<\/font><\/span>"Revenue_Type"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>      <<\/font><\/span>col <\/font><\/span>group=<\/font><\/span>"1"<\/font><\/span> sequence=<\/font><\/span>"2"<\/font><\/span> name=<\/font><\/span>"Order_Type"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>      <<\/font><\/span>col <\/font><\/span>group=<\/font><\/span>"0"<\/font><\/span> sequence=<\/font><\/span>"2"<\/font><\/span> name=<\/font><\/span>"Order_Quantity"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>      <<\/font><\/span>col <\/font><\/span>group=<\/font><\/span>"0"<\/font><\/span> sequence=<\/font><\/span>"3"<\/font><\/span> name=<\/font><\/span>"Terms"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>      <<\/font><\/span>col <\/font><\/span>group=<\/font><\/span>"2"<\/font><\/span> sequence=<\/font><\/span>"1"<\/font><\/span> name=<\/font><\/span>"Requested_Ship"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>      <<\/font><\/span>col <\/font><\/span>group=<\/font><\/span>"2"<\/font><\/span> sequence=<\/font><\/span>"2"<\/font><\/span> name=<\/font><\/span>"Requested_Install"<\/font><\/span>\/<\/font><\/span>><\/span>
\n<\/font>   <<\/font><\/span>\/sp:GroupCols<\/font><\/span>><\/span><\/p>\n

<<\/span><\/font>!– *******************************************
\n        end of non-generic code here
\n        ******************************************* —<\/font><\/span>><\/font><\/span>\n<\/p>\n

\nThere are many other ways to reference custom data, especially if you want to use the same strategy for many different reports. In this scenario, in production use, you would probably pass the set of columns into the transform as another, XSLT-specific argument. You can even pass the RDL as a parameter, and let the XSLT look up the column information!  You can also pass the location of an external lookup XML document holding the information about the columns, in whatever simplified format you like, something like what you see in the variable.  For this tutorial, I'm putting this information directly into the transform; it will help you  see what I'm doing more clearly. \n<\/p>\n

\nSo that's the end of the information that is report-specific in this XSLT file.  Now come the templates that actually do the work. There's only about 30 lines of code, as you'll see in the complete file (ConditionalColumnsExport.xslt (3.84 kb)<\/a>), and those 30 lines look more scary than they need to because I decided to parameterize the separator and delimiter.\n<\/p>\n

\nThere are two loops, one for the header line, and one for each detail row, that handle all the possible columns in the report and toss out any that are not marked with a "T" in the Groups variable, like this:\n<\/p>\n

\n    <<\/font><\/span>xsl:for-each <\/font><\/span>select=<\/font><\/span>"document('')\/xsl:stylesheet\/sp:GroupCols\/col[substring($Groups,position(),1) = 'T']"<\/font><\/span>><\/font><\/span>\n<\/p>\n

\n… the expression will look a little different depending on how you provide information about the full column set to the XSLT, but not very different.  The code inside each loop to provide the actual header line and rows is trivial.\n<\/p>\n

\nWith the parameters set as shown in the default strings, you'll get a result like this:\n<\/p>\n

\nSales_No,Order_Type,Order_Quantity,Terms,Requested_Ship
\n1-67901846,New,8,NET 30,2007-05-25T00:00:00
\n1-65162786,New,32,Special,2007-05-25T00:00:00
\n1-67980171,New,2,Trial 45 Days,2007-05-26T00:00:00
\n1-67992057,New,3,Trial 45 Days,2007-05-26T00:00:00
\n1-66282631,Used,10,Rental with Purchase Option,2007-05-21T00:00:00\n<\/p>\n

  <\/h4>\n

So that's it.<\/h4>\n

\nThat's the bug, and there's the workaround.\n<\/p>\n

Notice anything?<\/h5>\n

\nIf you look at the last column above, Requested_Ship, and compare it with the displayed output in the screenshots earlier in this post, you'll see that the data in the XML doesn't "know about" any of the formatting options you may have picked for display purposes in the RDL. \n<\/p>\n

\nThat's as expected.  You can take care of this in the XSLT with a little more work — and you can provide more intelligence about the formatting for each column in your custom lookup element than I have — or you can change the SELECT statement for the special export version of the report to output the columns pre-formatted. \n<\/p>\n

\nThe "real" CSV handler would have handled this for you… but, come to think of it, in many cases the raw data item is going to be exactly what you would prefer for a separated values result.  So we win, actually, we can have it either way.\n<\/p>\n

Before anybody asks<\/h5>\n

\nNo I haven't checked to see how this works in RS 2008.  To tell you the truth, until the whole mess with the report viewer control versions and Visual Studio dies down, and unless a client wants to upgrade, I'm not all that tempted.  I would if I had any free time, but I'd just be playing around.  Meanwhile, the RDLs are not compatible and I'm kinda busy with "real" work. I'd rather spend my play-round time answering questions like Steve's (I get a few almost every day) for other people who are also doing "real" work. \n<\/p>\n

\n"Faster would be better?" Not this time, I don't think so.\n<\/p>\n

\nSet curmudgeon mode off. <\/em><\/p>\n","protected":false},"excerpt":{"rendered":"

Steve Gavin wrote with an interesting question that, at first, I got backwards. He has a requirement for CSV export output from a report that conditionally hides columns, and he couldn't get the output the way he wanted it to be.  I immediately thought, "That makes sense, somehow the CSV renderer [and as it turns out, the XML renderer]Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[5,6,10,12],"tags":[],"class_list":["post-125","post","type-post","status-publish","format-standard","hentry","category-reporting","category-sql-server","category-xml-xslt","category-yaps"],"_links":{"self":[{"href":"https:\/\/spacefold.com\/lisa\/wp-json\/wp\/v2\/posts\/125","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/spacefold.com\/lisa\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/spacefold.com\/lisa\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/spacefold.com\/lisa\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/spacefold.com\/lisa\/wp-json\/wp\/v2\/comments?post=125"}],"version-history":[{"count":0,"href":"https:\/\/spacefold.com\/lisa\/wp-json\/wp\/v2\/posts\/125\/revisions"}],"wp:attachment":[{"href":"https:\/\/spacefold.com\/lisa\/wp-json\/wp\/v2\/media?parent=125"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/spacefold.com\/lisa\/wp-json\/wp\/v2\/categories?post=125"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/spacefold.com\/lisa\/wp-json\/wp\/v2\/tags?post=125"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}