                             ).without('shards')
                         )
                     )
+
+            # This query only checks the status of secondary indexes.
+            # It can throw an exception and failif the primary
+            # replica is unavailable (which happens immediately after
+            # a reconfigure).
+            failable_index_query = r.do(
+                r.db(system_db).table('table_config').get(this_id)
+                (table_config) ->
+                    r.db(table_config("db"))
+                    .table(table_config("name"), {useOutdated: true})
+                    .indexStatus()
+                    .pluck('index', 'ready', 'blocks_processed', 'blocks_total')
+                    .merge( (index) -> {
+                        id: index("index")
+                        db: table_config("db")
+                        table: table_config("name")
+                    }) # add an id for backbone
+            )
+
+            # Query to load data distribution and shard assignments.
+            # We keep this separate from the failable_index_query because we don't want
+            # to run it as often.
             # This query can throw an exception and failif the primary
             # replica is unavailable (which happens immediately after
             # a reconfigure). Since this query makes use of
-            # table.info() and table.indexStatus(), it's separated
-            # from the guaranteed query above.
-            failable_query = r.do(
+            # table.info(), it's separated from the guaranteed query above.
+            failable_misc_query = r.do(
                 r.db(system_db).table('table_status').get(this_id),
                 r.db(system_db).table('table_config').get(this_id),
-                r.db(system_db).table('server_config').coerceTo('array'),
-                (table_status, table_config, server_config) ->
+                r.db(system_db).table('server_config')
+                    .map((x) -> [x('name'), x('id')]).coerceTo('ARRAY').coerceTo('OBJECT'),
+                (table_status, table_config, server_name_to_id) ->
                     table_status.merge({
-                        indexes: r.db(table_status("db"))
-                            .table(table_status("name"), {useOutdated: true})
-                            .indexStatus()
-                            .pluck('index', 'ready', 'blocks_processed', 'blocks_total')
-                            .merge( (index) -> {
-                                id: index("index")
-                                db: table_status("db")
-                                table: table_status("name")
-                            }) # add an id for backbone
                         distribution: r.db(table_status('db'))
                             .table(table_status('name'), {useOutdated: true})
                             .info()('doc_count_estimates')

                                    .table(table_status('name'), {useOutdated: true})
                                    .info()('doc_count_estimates')(position)
                                primary:
                                    id: server_config.filter({name: shard("primary_replica")}).nth(0)("id")
                                    name: shard("primary_replica")
                                replicas: shard("replicas")
                                    .filter( (replica) -> replica.ne(shard("primary_replica")))
                                    .map (name) ->
                                        id: server_config.filter({name: name}).nth(0)("id")
                                        name: name
                        ).coerceTo('array')
                    })
            )
            # This timer keeps track of the failable query, so we can
            # cancel it when we navigate away from the table page.
            @failable_timer = driver.run failable_query, 1000, (error, result) =>
                if error?
                    console.log error.msg
                    return
                @error = null
                if @indexes?
                    @indexes.set _.map(result.indexes, (index) -> new Index index)
                else
                    @indexes = new Indexes _.map result.indexes, (index) ->
                        new Index index
                @table_view?.set_indexes @indexes
                if @distribution?
                    @distribution.set _.map result.distribution, (shard) ->
                        new Shard shard

            @distribution = null

            @guaranteed_timer = null
            @failable_index_timer = null
            @failable_misc_timer = null
            
            # Initialize the model with mostly empty dummy data so we can render it right away
            @model = new Table {id: id}
