return a_->lowestBuildID < b_->lowestBuildID;

                return
                    a_->highestGlobalPriority != b_->highestGlobalPriority ? a_->highestGlobalPriority > b_->highestGlobalPriority :
                    a_->lowestBuildID < b_->lowestBuildID;

    receiver buildsBumped(*conn, "builds_bumped");

        if (buildsCancelled.get() || buildsDeleted.get()) {
            printMsg(lvlTalkative, "got notification: builds cancelled");
            removeCancelledBuilds(*conn);

        if (buildsCancelled.get() || buildsDeleted.get() || buildsBumped.get()) {
            printMsg(lvlTalkative, "got notification: builds cancelled or bumped");
            processQueueChange(*conn);

        auto res = txn.parameterized("select id, project, jobset, job, drvPath, maxsilent, timeout, timestamp from Builds where id > $1 and finished = 0 order by id")(lastBuildId).exec();

        auto res = txn.parameterized("select id, project, jobset, job, drvPath, maxsilent, timeout, timestamp, globalPriority from Builds where id > $1 and finished = 0 order by id")(lastBuildId).exec();

            build->globalPriority = row["globalPriority"].as<int>();

        /* Update the lowest build ID field of each dependency. This
           is used by the dispatcher to start steps in order of build
           ID. */
        visitDependencies([&](const Step::ptr & step) {
            auto step_(step->state.lock());
            step_->lowestBuildID = std::min(step_->lowestBuildID, build->id);
        }, build->toplevel);

        build->propagatePriorities();

void State::removeCancelledBuilds(Connection & conn)

void Build::propagatePriorities()
{
    /* Update the highest global priority and lowest build ID fields
       of each dependency. This is used by the dispatcher to start
       steps in order of descending global priority and ascending
       build ID. */
    visitDependencies([&](const Step::ptr & step) {
        auto step_(step->state.lock());
        step_->highestGlobalPriority = std::max(step_->highestGlobalPriority, globalPriority);
        step_->lowestBuildID = std::min(step_->lowestBuildID, id);
    }, toplevel);
}
void State::processQueueChange(Connection & conn)

    std::set<BuildID> currentIds;

    std::map<BuildID, int> currentIds;

        auto res = txn.exec("select id from Builds where finished = 0");

        auto res = txn.exec("select id, globalPriority from Builds where finished = 0");

            currentIds.insert(row["id"].as<BuildID>());

            currentIds[row["id"].as<BuildID>()] = row["globalPriority"].as<BuildID>();

        if (currentIds.find(i->first) == currentIds.end()) {

        auto b = currentIds.find(i->first);
        if (b == currentIds.end()) {

        } else
            ++i;

            continue;
        }
        if (i->second->globalPriority < b->second) {
            printMsg(lvlInfo, format("priority of build %1% increased") % i->first);
            i->second->globalPriority = b->second;
            i->second->propagatePriorities();
        }
        ++i;

    int globalPriority;

    void propagatePriorities();

        /* The lowest build ID depending on this step. */

        /* The highest global priority of any build depending on this
           step. */
        int highestGlobalPriority{0};
        /* The lowest ID of any build depending on this step. */

    /* Check the queue for new builds. */

    void removeCancelledBuilds(Connection & conn);

    /* Handle cancellation, deletion and priority bumps. */
    void processQueueChange(Connection & conn);

sub bump : Chained('buildChain') PathPart('bump') {
    my ($self, $c, $x) = @_;
    my $build = $c->stash->{build};
    requireProjectOwner($c, $build->project); # FIXME: require admin?
    $c->model('DB')->schema->txn_do(sub {
        $build->update({globalpriority => time()});
    });
    $c->flash->{successMsg} = "Build has been bumped to the front of the queue.";
    $c->res->redirect($c->uri_for($self->action_for("build"), $c->req->captures));
}

        entity => [$c->model('DB::Builds')->search({finished => 0}, { order_by => ["id"]})]

        entity => [$c->model('DB::Builds')->search({finished => 0}, { order_by => ["globalpriority desc", "id"]})]

  data_type: 'integer'
  default_value: 0
  is_nullable: 0
=head2 globalpriority

  { data_type => "integer", default_value => 0, is_nullable => 0 },
  "globalpriority",

# Created by DBIx::Class::Schema::Loader v0.07043 @ 2015-07-30 16:52:20
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:Y2lDtgY8EBLOuCHAI8fWRQ

# Created by DBIx::Class::Schema::Loader v0.07043 @ 2015-08-10 15:10:41
# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:rjifgnPtjY96MaQ7eiGzaA

          <li><a href="[% c.uri_for('/build' build.id 'bump') %]">Bump up</a></li>

    -- Information about scheduled builds.

    -- Priority within a jobset, set via meta.schedulingPriority.

    -- Priority among all builds, used by the admin to bump builds to
    -- the front of the queue via the web interface.
    globalPriority integer not null default 0,

create function notifyBuildBumped() returns trigger as 'begin notify builds_bumped; return null; end;' language plpgsql;
create trigger BuildBumped after update on Builds for each row
  when (old.globalPriority != new.globalPriority) execute procedure notifyBuildBumped();

alter table Builds add column globalPriority integer not null default 0;
create function notifyBuildBumped() returns trigger as 'begin notify builds_bumped; return null; end;' language plpgsql;
create trigger BuildBumped after update on Builds for each row
  when (old.globalPriority != new.globalPriority) execute procedure notifyBuildBumped();