         if call.args.length == 0
             return prologue + epilogue
 
-        @doList(call.args, @_doAtom, ', ', prologue, epilogue)
+        @doList(call.args, @_doColumnAtom, ', ', prologue, epilogue)
 
 
     doList: (collection, fn = @f, separator = ', ', prologue = '', epilogue = '') ->

        names = []
        values = []
        for k, v of i.values
            names.push(@_doAtom(k))
            values.push(@f(v))

        ret += " (#{names.join(', ')}) VALUES (#{values.join(', ')})"


    update: (u) ->
        ret = "UPDATE #{@_doTargetTable(u.targetTable)} SET "

        values = ("#{@_doAtom(k)} = #{@f(v)}" for k, v of u.values)
        ret += values.join(', ')

        ret += @where(u)
        return ret

    delete: (d) ->
        ret = "DELETE FROM #{@_doTargetTable(d.targetTable)}"

    column: (c) ->
        atom = _.firstOrSelf(c)
        alias = _.secondOrNull(c)
        return @_doColumnAtom(atom, @_doAliasedColumn, alias)

    _doAliasedColumn: (token, schema, alias) ->
        s = @_doToken(token, schema)
        alias = @_doAlias(token, schema, alias)
        if (alias? && alias != schema?.name)
            s += " as #{@delimit(alias)}"

        return s

    # A column might be an actual table column, but it could also be an expression,
    # SQL literal, subquery, etc.
    _doColumnAtom: (atom, fn = @_doToken, p = null) ->
        token = @tokenizeAtom(atom)
        columnSchema = @_findColumnSchema(token)
        return fn.call(@, token, columnSchema, p)

    _doToken: (token, schema) ->
        if (schema?)
