Sometimes, it’s desirable to synchronize child report page settings to their parents. Brian Welcker posted a code sample showing how to automate this property copying using the now old-style .Net 2.0 Web Reference approach. Let’s implement the same functionality using the modern (though, unfortunately, more verbose) Service Reference approach.

For our example, we’ll use C# executed in the context of a Console Application.

Creating the Service Reference

In Solutions Explorer, right-click on the project’s References folder and select Add Service Reference. In the dialog that’s displayed, input your reporting server’s web service URL, then click Go. Once the service information fetching completes, click OK. (If you’d like, adjust the namespace to be used for the service proxy classes before clicking OK.)

Code

using System;
using System.ServiceModel;
using rs = PropertySync.ReportingService;

namespace PropertySync
{
    class Program
    {
        static void Main(string[] args)
        {
            var service = new rs.ReportingService2010SoapClient();

            // Retrieve a list of reports.
            rs.CatalogItem[] reports = null;
            service.ListChildren(new rs.TrustedUserHeader(), "/", true, out reports);

            // List of properties to copy from parent to linked reports.
            var requestedProperties = new rs.Property[] {
                new rs.Property { Name = "PageHeight" },
                new rs.Property { Name = "PageWidth" },
                new rs.Property { Name = "TopMargin" },
                new rs.Property { Name = "BottomMargin" },
                new rs.Property { Name = "LeftMargin" },
                new rs.Property { Name = "RightMargin" }
            };

            foreach (var report in reports) {
                Console.Write("{0} ({1})", report.Name, report.Path);

                if (report.TypeName == "LinkedReport") {
                    string parentReportLink = null;
                    service.GetItemLink(new rs.TrustedUserHeader(), report.Path, out parentReportLink);

                    // Fetch interested property values from parent report.
                    ReportingService.Property[] parentValues = null;
                    service.GetProperties(new rs.ItemNamespaceHeader(), new rs.TrustedUserHeader(), parentReportLink, requestedProperties, out parentValues);

                    // Set the child report's properties to the just-fetched values.
                    service.SetProperties(new rs.TrustedUserHeader(), report.Path, parentValues);
                    Console.WriteLine(" -- properties updated from {0}", parentReportLink);
                } else {
                    Console.WriteLine(" -- non-linked - skipped");
                }
            }
        }
    }
}

Compile and run. If the application executes successfully, we’re done!

Configuring the Binding

If the program fails with a security error (perhaps a MessageSecurityException), you probably need to adjust your web service binding configuration. Your code is probably trying to execute web service methods anonymously (without passing authentication credentials) while SSRS is probably configured to require client authentication.

The exact binding settings required depend on your server’s configuration—detailing the various possibilities is beyond the scope of this article. A common client configuration scenario is illustrated below:

var binding = new BasicHttpBinding(BasicHttpSecurityMode.TransportCredentialOnly);
binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Windows;

var endpointUri = "http://reporting/ReportServer_SQL/ReportService2010.asmx";
var service = new rs.ReportingService2010SoapClient(binding, new EndpointAddress(endpointUri));
service.ClientCredentials.Windows.AllowedImpersonationLevel = System.Security.Principal.TokenImpersonationLevel.Impersonation;

If you are using integrated (Windows) security, you may need to run your application as an administrator in order for credentials to be passed. (Hint: if you are launching the program from within Microsoft Visual Studio, run Visual Studio as an administrator.)

Shortly prior to this problem appearing, I had set a couple of configuration directives in a php.ini file fragment—something like this:

post_max_size	        2GB
upload_max_filesize     2GB

Looks correct, doesn’t it? Nope!

I learned the hard way that PHP uses single letter abbreviations to indicate kilobytes (K), megabytes (M) and gigabytes (G)! Dropping the “B” off of each “GB” fixed the problem—PHP went back to properly populating $_POST.

Interestingly, phpinfo() and ini_get() won’t necessarily cough about the extraneous “B” being present. This deceptive acceptance of incorrectly formatted configuration values can complicate debugging.

Thanks to Stack Overflow for providing the answer I needed to solve this perplexing $_POST issue!

Status code 127 is commonly used to indicate “command not found.” The error message’s bracketed portion indicates that Rake attempted to run an executable named “zip,” passing to it several arguments. By default, Windows systems do not include a command named zip. Hence, the error.

To fix this problem, configure Rake::PackageTask to use an alternative zip command by setting its zip_command property. In the example below, notice the inner quotes surrounding the path to the command. These were necessitated by the space in “Program Files.”

Rake::PackageTask.new('Module', :noversion) do |p|
  p.need_zip = true
  p.zip_command = '"C:\Program Files\7-Zip\7z.exe" a -tzip'
  p.package_files.include(..)
end

Rake::PackageTask also provides a tar_command property which can be used to override the command used to gzip and bzip2 archives.

MySQL supports incomplete dates out of the box. Simply insert zeros in place of the missing date part:

INSERT INTO TestTable (ID, IncompleteDate) VALUES
(NULL, '0000-07-10'), -- unknown year
(NULL, '2012-00-15'), -- unknown month
(NULL, '2012-06-00'); -- unknown day

Microsoft SQL Server doesn’t support incomplete dates so zeroing out a missing date part won’t work. Let’s examine several ways to work around this limitation.

Placeholder Year

Suppose we’re storing birth dates. Let’s say we know that a day and month will always be provided but sometimes the year will be omitted. That is, sometimes we’ll need to store dates in the format of March 18 (unknown year).

To use the placeholder year approach, pick a year outside the range of expected year values to use as the unknown year placeholder. In order to accommodate the date February 29 (unknown year), the placeholder year must be a leap year.  In the case of our birth date example, let’s choose year 1200 as the unknown placeholder. It’s well outside the range of birth dates used in a normal line of business application and is a leap year. To store March 18 (unknown year), we’ll insert “1200-03-18″.

With this approach, normal SQL date functions work. However, if computations involving the year are invoked, dates using the placeholder year must be filtered out.

-- Failed Attempt: Find individuals born before 1980.
-- (Problem: Records with unknown birth years will be included in the result set.)
SELECT *
FROM TestTable
WHERE YEAR(BirthDate) < 1980

-- Successful Attempt: Find individuals born before 1980
SELECT *
FROM TestTable
WHERE YEAR(BirthDate) > 1200 AND YEAR(BirthDate) < 1980

Date Parts in Separate Columns

To implement, create three columns: day, month, year. If a particular date part may be unknown, allow the associate column to store null values. To insert March 18 (unknown year), we execute:

INSERT INTO TestTable (BirthDay, BirthMonth, BirthYear) VALUES
(3, 18, NULL);

This method eliminates the use of a placeholder year and allows for unknown days and months, benefits not offered by the placeholder year approach. Its principle downside? Loss of SQL Server’s built-in date functionality (date functions, conversion/cast operations and date validation checking).

Date validation can be manually recreated using a somewhat complex set of CHECK constraints. The loss of date functions may not be the end of the world. In fact, some operations may become easier. No longer is MONTH(BirthDate) necessary. Selecting BirthMonth now achieves the same effect.

CLR User-Defined Type

In addition to the benefits of the date parts in separate columns approach, a CLR user-defined type (UDT) allows for a degree of cast/conversion operations and stores its data in a single column on the server. With this method, all functionality is packaged into a data type which can easily be reused server-wide. This data type can also be included in client-side programs, allowing those programs to locally work with retrieved data using all the methods and properties defined by the custom data type.

The downside? Out of the methods discussed, this is the most complex to implement

Solution

Include/require (perhaps using require_once) app/Mage.php in the code you execute from outside of Magento. When Mage.php is included, the code in that file will register Magento’s autoloader with PHP. Also, Mage.php contains the method definitions for the Mage singleton methods.

Learn more about unit testing code written for Magento on Magento’s wiki.

Yes! In your authorization request, put the memo text in a field called T_memo.

Thanks to Cornerstone, one of my client’s credit card processing vendor, for passing on this tip!

Foundation: The Script Comes First

Let’s start by creating a script that displays an Insert File dialog. This script should contain two steps: Set Error Options [On] followed by Insert File [Table::FieldName] (where Table is the name of the table containing the container field and FieldName is the name of the container field).

(Set Error Options [On] isn’t strictly necessary. However, if it’s left out and the user clicks cancels out of the Insert File dialog, a script error will be displayed.)

The Container’s Button Setup

Now, configure the container field’s button setup so that clicking on the field runs the script we just created. While editing the layout, right-click on the field, choose Button Setup, change the action to Perform Script then click Specify and select the script you created above. Switch from edit layout mode to view mode, then click on the container field. You should see an Insert File dialog. Excellent!

Ah…but there’s a catch. Normally, to export or delete the file stored in the container, you’d right-click on the field and choose the appropriate option from the pop-up menu. However, when we configured button setup, we overrode the field’s click behavior for both left- and right-clicks. Right-click on the field and Insert File appears instead of the pop-up menu. Unfortunately, FileMaker Pro doesn’t provide an easy way to limit our script so that it only processes left-clicks. If we want the script to handle clicks, it must handle all of them. What can we do about this?

Separate Buttons

It’s not pretty, but it works. Next to the container field, create two buttons: export and delete. Via button setup, associate each with a script that performs the appropriate action.

Export’s script contains two steps: Set Error Capture [On] and Export Field Contents [Table::FieldName].

Delete’s script uses an If statement to check if the container field is empty. If the field is not empty, the script calls Set Field [Table::FieldName, ""].

Why the If statement? Without it, clicking the delete button on a brand-new, empty portal row sets the container field to a value which causes the portal row to be inserted into the table, even though it is empty. The If statement prevents this.

To improve the user interface experience, conditional formatting can be used to make the two buttons appear disabled when the container field is empty.

When SET FMTONLY is OFF (the default), SQL Server processes control-of-flow statements normally. In the case of an IF statement, SQL Server determines which conditional expression evaluates to true and then executes the code associated with that expression. Turn FMTONLY to ON and SQL Server executes every conditional branch, even those associated with conditions evaluating to false!

To illustrate, if SET FMTONLY is OFF, executing the following SQL returns one result set containing a column named 1 = 1. With SET FMTONLY ON, the below SQL returns two result sets: one containing the already-mentioned 1 = 1 column and a second containing a column named 1 = 2. When FMTONLY is ON, the code blocks associated with both of these conditional expressions are executed—even though one of the conditions evaluates to false!

IF 1 = 1
	SELECT '1 = 1' = 'Value'
ELSE IF 1 = 2
	-- Normally, this SELECT statement would not be executed because 1 does not equal 2.
	SELECT '1 = 2' = 'Value'
END

Setting SET FMTONLY ON also changes the behavior of CONTINUE, RETURN and BREAK statements, TRY…CATCH blocks and WAITFOR statement as demonstrated by the following SQL:

SET FMTONLY ON;

DECLARE @counterContinue INT;
SET @counterContinue = 1;

WHILE (@counterContinue < 10) BEGIN
	SET @counterContinue = @counterContinue + 1;
	CONTINUE;
	-- Normally, this next SELECT statement will never be executed because of the proceeding
	-- CONTINUE; however, SET FMTONLY ON causes it to be processed.
	SELECT 'Post Continue Table' = 'Value';
END

DECLARE @counterBreak INT;
SET @counterBreak = 1;

WHILE (@counterBreak < 10) BEGIN
	SET @counterBreak = @counterBreak + 1;
	BREAK;
	-- If SET FMTONLY where OFF, this next SELECT statement wouldn't be run but
	-- because SET FMTONLY is ON, it will be executed.
	SELECT 'Post Break Table' = 'Value';
END

BEGIN TRY
	SELECT 'Try Table Column' = 'Value'
END TRY
-- Normally, this CATCH statement will only be executed if an error occurs in the TRY
-- statement block. With SET FMTONLY ON, the CATCH block will always be executed.
BEGIN CATCH
	SELECT 'Catch Table Column' = 'Value'
END CATCH

-- With SET FMTONLY ON, the no waiting occurs.
BEGIN
    WAITFOR DELAY '02:00';
    SELECT 'Wait' = 'Value'
END;

-- If SET FMTONLY is OFF, the code below this RETURN statement will never be executed.
-- When SET FMTONLY ON, the following SELECT statement is executed.
RETURN
AfterReturnLabel:
	SELECT 'After Return Label Table' = 'Value'

Why does FMTONLY ON cause this behavior change?

Here’s my guess: SET FMTONLY ON is used to retrieve metadata describing the result set(s) that could be returned when the specified query is run (i.e. run with SET FMTONLY OFF). In order for SQL Server to provide metadata on all result sets that could be returned, SQL Server must process all branches of all control-of-flow statements.

The process is simple:

• Create an instance of the Magento product,
  • give it a custom price by calling setSpecialPrice,
  • then save the product instance (store must be running as the admin store).
• Next, grab the Magento cart object (a singleton),
  • add the product instance to the cart,
  • then save the cart.

In order to save the product after giving it a special price, the store must be running as what Magento calls the “admin store” (confusing terminology—think of it as meaning “running in admin mode”). If save is called while the store is running in its default mode (in Magento-speak, “running as the distro store”), the following error will occur:

Warning: Invalid argument supplied for foreach()  in app\code\core\Mage\Eav\Model\Entity\Abstract.php on line 1068

#0 app\code\core\Mage\Eav\Model\Entity\Abstract.php(1068): mageCoreErrorHandler(2, 'Invalid argumen...', 'C:\Program File...', 1068, Array)
#1 app\code\core\Mage\Eav\Model\Entity\Abstract.php(1012): Mage_Eav_Model_Entity_Abstract->_collectSaveData(Object(Mage_Catalog_Model_Product))
#2 app\code\core\Mage\Core\Model\Abstract.php(318): Mage_Eav_Model_Entity_Abstract->save(Object(Mage_Catalog_Model_Product))
#3 app\code\local\BenGribaudo\MyModule\controllers\IndexController.php(26): Mage_Core_Model_Abstract->save()
#4 app\code\local\BenGribaudo\MyModule\controllers\IndexController.php(8): BenGribaudo_MyModule_IndexController->processAdd()
#5 app\code\core\Mage\Core\Controller\Varien\Action.php(418): BenGribaudo_MyModule_IndexController->indexAction()
#6 app\code\core\Mage\Core\Controller\Varien\Router\Standard.php(253): Mage_Core_Controller_Varien_Action->dispatch('index')
#7 app\code\core\Mage\Core\Controller\Varien\Front.php(176): Mage_Core_Controller_Varien_Router_Standard->match(Object(Mage_Core_Controller_Request_Http))
#8 app\code\core\Mage\Core\Model\App.php(340): Mage_Core_Controller_Varien_Front->dispatch()
#9 app\Mage.php(627): Mage_Core_Model_App->run(Array)
#10 index.php(80): Mage::run('', 'store')
#11 {main}

After saving the product instance, be sure to switch the store back to normal (a.k.a. distro) mode before adding the product to the cart. Otherwise, the item just added to the cart will disappear out of the cart. (Most articles I’ve seen on this topic leave out this important step.)

Code Example

$product = Mage::getModel('catalog/product');
$product->load($productId);
$product->setSpecialPrice($price);
Mage::app()->setCurrentStore(Mage_Core_Model_App::ADMIN_STORE_ID);
$product->save();
Mage::app()->setCurrentStore(Mage_Core_Model_App::DISTRO_STORE_ID);

$cart = Mage::getSingleton('checkout/cart');
$cart->addProduct($product, array('qty' => $quantity));
$cart->save();

Can the garbage collection process be forced to run?

MSDN says that GC.Collect() “forces garbage collection.” This is as clear as can be. Calling GC.Collect() doesn’t request or suggest garbage collection—when it is called, collection always occurs.

When collection is induced, will all eligible objects be destroyed?

Calling GC.Collect() destroys all non-finalizable collection-eligible objects. Finalizable object destruction involves two additional steps (assuming that no object resurrection occurs): after the initial GC.Collect() call, wait for the finalizers to run, then call GC.Collect() a second time. In both cases, the collector will not mysteriously skip over eligible objects. Any object which qualifies for destruction will be discarded.

Destroying an object is different from freeing the memory used by the object. If a WeakReference points to an object which is garbage collected, the WeakReference’s IsAlive property will equal false—the object has been destroyed. However, sometimes it is inefficient for the garbage collector to free up the memory used by the destroyed object. GC.Collect()‘s documentation alludes to this with the word “try” when it says “Use this method to try to reclaim all memory that is inaccessible” (emphasis mine). The object has been destroyed even if the memory it used has not been released.

Closing Thoughts

Other programming languages’ garbage collection implementations may operate differently. It’s important not to confuse the specifics of how they work with how .Net works.

For details on how .Net determines when an object is eligible for garbage collection, read Jeffrey Richter’s MSDN Magazine article Garbage Collection: Automatic Memory Management in the Microsoft .NET Framework.

Thanks goes to Maoni Stephens for helping me understand several pertinent garbage collection particulars.