, order_by => ["me.id", "buildoutputs.name"]

    foreach my $build ($c->stash->{channelBuilds}->all) {
        my $outPath = $build->get_column("outpath");
        my $outName = $build->get_column("outname");
        next if $checkValidity && !isValidPath($outPath);
        push @storePaths, $outPath;
        my $pkgName = $build->nixname . "-" . $build->system . "-" . $build->id . ($outName ne "out" ? "-" . $outName : "");
        push @{$c->stash->{nixPkgs}}, { build => $build, name => $pkgName, outPath => $outPath, outName => $outName };
        # Put the system type in the manifest (for top-level paths) as
        # a hint to the binary patch generator.  (It shouldn't try to
        # generate patches between builds for different systems.)  It
        # would be nice if Nix stored this info for every path but it
        # doesn't.
        $c->stash->{systemForPath}->{$outPath} = $build->system;
    };

    my @builds = $c->stash->{channelBuilds}->all;
    for (my $n = 0; $n < scalar @builds; ) {
        # Since channelData is a join of Builds and BuildOutputs, we
        # need to gather the rows that belong to a single build.
        my $build = $builds[$n++];
        my @outputs = ($build);
        push @outputs, $builds[$n++] while $n < scalar @builds && $builds[$n]->id == $build->id;
        @outputs = grep { $_->get_column("outpath") } @outputs;
        my $outputs = {};
        foreach my $output (@outputs) {
            my $outPath = $output->get_column("outpath");
            next if $checkValidity && !isValidPath($outPath);
            $outputs->{$output->get_column("outname")} = $outPath;
            push @storePaths, $outPath;
            # Put the system type in the manifest (for top-level
            # paths) as a hint to the binary patch generator.  (It
            # shouldn't try to generate patches between builds for
            # different systems.)  It would be nice if Nix stored this
            # info for every path but it doesn't.
            $c->stash->{systemForPath}->{$outPath} = $build->system;
        }

        next if !%$outputs;
        my $pkgName = $build->nixname . "-" . $build->system . "-" . $build->id;
        push @{$c->stash->{nixPkgs}}, { build => $build, name => $pkgName, outputs => $outputs };
    }

                 , order_by => ["build.id", "buildoutputs.name"]

        my $s = "";
        $s .= "  # $pkg->{name}\n";
        $s .= "  ${\escape $build->get_column('job')} = {\n";
        $s .= "    type = \"derivation\";\n";
        $s .= "    name = ${\escape ($build->get_column('releasename') or $build->nixname)};\n";
        $s .= "    system = ${\escape $build->system};\n";
        $s .= "    outPath = ${\escape $pkg->{outPath}};\n";
        $s .= "    meta = {\n";
        $s .= "      description = ${\escape $build->description};\n"
            if $build->description;
        $s .= "      longDescription = ${\escape $build->longdescription};\n"
            if $build->longdescription;
        $s .= "      license = ${\escape $build->license};\n"
            if $build->license;
        $s .= "      maintainers = ${\escape $build->maintainers};\n"
            if $build->maintainers;
        $s .= "    };\n";
        $s .= "  };\n\n";
        $perSystem{$build->system} .= $s;

        $perSystem{$build->system}->{$build->get_column('job')} = $pkg;

    my $res = "{ system ? builtins.currentSystem }:\n\n";

    my $res = <<EOF;
{ system ? builtins.currentSystem }:
let
  mkFakeDerivation = attrs: outputs:
    let
      outputNames = builtins.attrNames outputs;
      common = attrs // outputsSet //
        { type = "derivation";
          outputs = outputNames;
          all = outputsList;
        };
      outputToAttrListElement = outputName:
        { name = outputName;
          value = common // {
            inherit outputName;
            outPath = builtins.getAttr outputName outputs;
          };
        };
      outputsList = map outputToAttrListElement outputNames;
      outputsSet = builtins.listToAttrs outputsList;
    in outputsSet;
in

EOF

        $res .= $perSystem{$system};

        foreach my $job (keys $perSystem{$system}) {
            my $pkg = $perSystem{$system}->{$job};
            my $build = $pkg->{build};
            $res .= "  # Hydra build ${\$build->id}\n";
            my $attr = $build->get_column('job');
            $attr =~ s/\./-/g;
            $res .= "  ${\escape $attr} = (mkFakeDerivation {\n";
            $res .= "    type = \"derivation\";\n";
            $res .= "    name = ${\escape ($build->get_column('releasename') or $build->nixname)};\n";
            $res .= "    system = ${\escape $build->system};\n";
            $res .= "    meta = {\n";
            $res .= "      description = ${\escape $build->description};\n"
                if $build->description;
            $res .= "      longDescription = ${\escape $build->longdescription};\n"
                if $build->longdescription;
            $res .= "      license = ${\escape $build->license};\n"
                if $build->license;
            $res .= "      maintainers = ${\escape $build->maintainers};\n"
                if $build->maintainers;
            $res .= "    };\n";
            $res .= "  } {\n";
            my @outputNames = sort (keys $pkg->{outputs});
            $res .= "    ${\escape $_} = ${\escape $pkg->{outputs}->{$_}};\n" foreach @outputNames;
            my $out = defined $pkg->{outputs}->{"out"} ? "out" : $outputNames[0];
            $res .= "  }).$out;\n\n";
        }

          [% IF pkg.outName != 'out' %] [[% pkg.outName %]][% END %]