[LNT] Sort fields according to order defined in YAML files.

[marxin]

Summary

I would consider it handy to have possibility to sort metrics. Some can be more
important and one would like to see them on top.

[cmatthews]

LGTM.

lnt/trunk/lnt/server/db/testsuite.py

def from_json(data):
             else:
                 field = RunField(name)
                 run_fields.append(field)
         ts.run_fields = run_fields
         ts.order_fields = order_fields
         assert(len(order_fields) > 0)
 
         sample_fields = []
-        for metric_desc in data['metrics']:
+        for index, metric_desc in enumerate(data['metrics']):
             name = metric_desc['name']
             bigger_is_better = metric_desc.get('bigger_is_better', False)
             metric_type_name = metric_desc.get('type', 'Real')
             display_name = metric_desc.get('display_name')
             unit = metric_desc.get('unit')
             unit_abbrev = metric_desc.get('unit_abbrev')
             if not testsuitedb.is_known_sample_type(metric_type_name):
                 raise ValueError("Unknown metric type '%s'" %
                                  metric_type_name)
             metric_type = SampleType(metric_type_name)
             bigger_is_better_int = 1 if bigger_is_better else 0
-            field = SampleField(name, metric_type, status_field=None,
+            field = SampleField(name, metric_type, index, status_field=None,
                                 bigger_is_better=bigger_is_better_int,
                                 display_name=display_name, unit=unit,
                                 unit_abbrev=unit_abbrev)
             sample_fields.append(field)
         ts.sample_fields = sample_fields
         ts.jsonschema = data
         return ts
 
class SampleField(FieldMixin, Base):
     status_field_id = Column("status_field", Integer, ForeignKey(
             'TestSuiteSampleFields.ID'))
     status_field = relation('SampleField', remote_side=id, lazy='immediate')
 
     # Most real type samples assume lower values are better than higher values.
     # This assumption can be inverted by setting this column to nonzero.
     bigger_is_better = Column("bigger_is_better", Integer)
 
-    def __init__(self, name, type, status_field=None, bigger_is_better=0,
+    def __init__(self, name, type, schema_index, status_field=None, bigger_is_better=0,
                  display_name=None, unit=None, unit_abbrev=None):
         self.name = name
         self.type = type
         self.status_field = status_field
         self.bigger_is_better = bigger_is_better
         self.display_name = name if display_name is None else display_name
         self.unit = unit
         self.unit_abbrev = unit_abbrev
+        self.schema_index = schema_index
 
         # Column instance for fields which have been bound (non-DB
         # parameter). This is provided for convenience in querying.
         self.column = None
 
     @sqlalchemy.orm.reconstructor
     def init_on_load(self):
         self.display_name = self.name
         self.unit = None
         self.unit_abbrev = None
+        self.schema_index = -1
 
     def __repr__(self):
         return '%s%r' % (self.__class__.__name__, (self.name, self.type, ))
 
     def __copy__(self):
-        return SampleField(self.name, self.type, self.status_field,
+        return SampleField(self.name, self.type, self.schema_index, self.status_field,
                            self.bigger_is_better, self.display_name, self.unit,
                            self.unit_abbrev)
 
     def copy_info(self, other):
         self.display_name = other.display_name
         self.unit = other.unit
         self.unit_abbrev = other.unit_abbrev
+        self.schema_index = other.schema_index
 
 
 def _upgrade_to(connectable, tsschema, new_schema, dry_run=False):
     new = json.loads(new_schema.jsonschema)
     old = json.loads(tsschema.jsonschema)
     ts_name = new['name']
     if old['name'] != ts_name:
         raise _MigrationError("Schema names differ?!?")

lnt/trunk/lnt/server/db/testsuitedb.py

def __init__(self, v4db, name, test_suite):
         self.v4db = v4db
         self.name = name
         self.test_suite = test_suite
 
         # Save caches of the various fields.
         self.machine_fields = list(self.test_suite.machine_fields)
         self.order_fields = list(self.test_suite.order_fields)
         self.run_fields = list(self.test_suite.run_fields)
-        self.sample_fields = list(self.test_suite.sample_fields)
+        self.sample_fields = list(sorted(self.test_suite.sample_fields,
+            key = lambda s: s.schema_index))
         sample_field_indexes = dict()
+
         for i, field in enumerate(self.sample_fields):
             sample_field_indexes[field.name] = i
         self.sample_field_indexes = sample_field_indexes
 
         self.base = sqlalchemy.ext.declarative.declarative_base()
 
         # Create parameterized model classes for this test suite.
         class ParameterizedMixin(object):
def __init__(self, v4db, name, test_suite):
 
             def load(self, profileDir):
                 return profile.Profile.fromFile(os.path.join(profileDir,
                                                              self.filename))
 
         class Sample(self.base, ParameterizedMixin):
             __tablename__ = db_key_name + '_Sample'
 
-            fields = self.sample_fields
+            fields = list(sorted(self.sample_fields, key = lambda x: self.sample_field_indexes[x.name]))
             id = Column("ID", Integer, primary_key=True)
             # We do not need an index on run_id, this is covered by the
             # compound (Run(ID),Test(ID)) index we create below.
             run_id = Column("RunID", Integer, ForeignKey(Run.id), index=True)
             test_id = Column("TestID", Integer, ForeignKey(Test.id),
                              index=True)
             profile_id = Column("ProfileID", Integer, ForeignKey(Profile.id))