anchor.diff:  
       final rows = await _enqueue(query, timeoutInSeconds: timeoutInSeconds);
       final columns = query.fieldDescriptions;
  -    await _connection._oidCache._resolveOids(this, columns);
  +    await _connection._oidCache._resolveTableNames(this, columns);
       return _mapifyRows(rows, columns);
     }
   
  
positive.code: 
    List<Map<String, Map<String, dynamic>>> _mapifyRows(
        List<List<dynamic>> rows, List<FieldDescription> columns) {
      columns.forEach((desc) {
        desc.resolvedTableName =
            _connection._oidCache._tableOIDNameMap[desc.tableID];
      });
  
      final tableNames = columns.map((c) => c.resolvedTableName).toSet().toList();
      return rows.map((row) {
        final rowMap = Map<String, Map<String, dynamic>>.fromIterable(tableNames,
            key: (name) => name as String, value: (_) => <String, dynamic>{});
  
        final iterator = columns.iterator;
        row.forEach((column) {
          iterator.moveNext();
          rowMap[iterator.current.resolvedTableName][iterator.current.fieldName] =
              column;
        });
  
        return rowMap;
      }).toList();
    }
  
negative.code: class _OidCache {
    final _tableOIDNameMap = <int, String>{};
  
    Future _resolveTableNames(
        PostgreSQLExecutionContext c, List<FieldDescription> columns) async {
      //todo (joeconwaystk): If this was a cached query, resolving is table oids is unnecessary.
      // It's not a significant impact here, but an area for optimization. This includes
  