RavenDB Awesome Feature of the Day: Formatted Indexes

there is a chance that you’ll look at me strangely for calling this the “feature of the day”. but that is actually quite a important little feature.

here is the deal, let us say that you have the following index

public class orders_search : abstractindexcreationtask<order, orders_search.reduceresult>
{
    public class reduceresult
    {
        public string query { get; set; }
        public datetime lastpaymentdate { get; set; }
    }

    public orders_search()
    {
        map = orders => from order in orders
                        let lastpayment = order.payments.lastordefault()
                        select new
                        {
                            query = new object[]
                            {
                                order.firstname, 
                                order.lastname, 
                                order.ordernumber, 
                                order.email, 
                                order.email.split('@'),
                                order.companyname,
                                order.payments.select(payment => payment.paymentidentifier),
                                order.licenseids
                            },
                            lastpaymentdate = lastpayment == null ? order.orderedat : lastpayment.at
                        };
    }
}

and you are quite happy with it. but that is the client side perspective. we don’t have any types on the server, so you can’t just execute this there. instead, we send a string representing the index to the server. that string is actually the output of the linq expression, which looks like this:

this is… somewhat hard to read, i think you’ll agree. so we had some minimal work done to improve this, and right now what you’ll get is (you’ll likely see it roll off the screen, that is expected):

docs.orders
    .select(order => new {order = order, lastpayment = order.payments.lastordefault()})
    .select(__h__transparentidentifier0 => new {query = new system.object []{__h__transparentidentifier0.order.firstname, __h__transparentidentifier0.order.lastname, __h__transparentidentifier0.order.ordernumber, __h__transparentidentifier0.order.email, __h__transparentidentifier0.order.email.split(new system.char []{'@'}), __h__transparentidentifier0.order.companyname, __h__transparentidentifier0.order.payments
    .select(payment => payment.paymentidentifier), __h__transparentidentifier0.order.licenseids}, lastpaymentdate = __h__transparentidentifier0.lastpayment == null ? __h__transparentidentifier0.order.orderedat : __h__transparentidentifier0.lastpayment.at})

this is still quite confusing, actually . but still better than the alternative.

as i said, it seems like a little thing, but those things are important. an index in its compiled form that is hard to understand for a user is a support issue for us. we needed to resolve this issue.

the problem is that source code beautifying is non trivial. i started playing with parsers a bit, but it was all way too complex. then i had an affiany. i didn’t actually care about the code, i just wanted it sorted. there aren’t many c# code beautifiers around, but there are a lot for javascript.

i started with the code from http://jsbeautifier.org/ , which rekna anker had already ported to c# . from there, it was an issue of making sure that for my purposes, the code generated the right output. i had to teach it c# idioms such as @foo, null coalescent and lambda expressions, but that sounds harder than it actually was. with that done, we go this output:

docs.orders.select(order => new {
    order = order,
    lastpayment = order.payments.lastordefault()
}).select(__h__transparentidentifier0 => new {
    query = new system.object[] {
        __h__transparentidentifier0.order.firstname,
        __h__transparentidentifier0.order.lastname,
        __h__transparentidentifier0.order.ordernumber,
        __h__transparentidentifier0.order.email,
        __h__transparentidentifier0.order.email.split(new system.char[] {
            '@'
        }),
        __h__transparentidentifier0.order.companyname,
        __h__transparentidentifier0.order.payments.select(payment => payment.paymentidentifier),
        __h__transparentidentifier0.order.licenseids
    },
    lastpaymentdate = __h__transparentidentifier0.lastpayment == null ? __h__transparentidentifier0.order.orderedat : __h__transparentidentifier0.lastpayment.at
})

and this is actually much better. still not good enough, mind. we can do better than that. it is a simple change:

docs.orders.select(order => new {
    order = order,
    lastpayment = order.payments.lastordefault()
}).select(this0 => new {
    query = new system.object[] {
        this0.order.firstname,
        this0.order.lastname,
        this0.order.ordernumber,
        this0.order.email,
        this0.order.email.split(new system.char[] {
            '@'
        }),
        this0.order.companyname,
        this0.order.payments.select(payment => payment.paymentidentifier),
        this0.order.licenseids
    },
    lastpaymentdate = this0.lastpayment == null ? this0.order.orderedat : this0.lastpayment.at
})

and now we got to something far more readable .