← Back to branch summary

~ubuntu-branches/ubuntu/trusty/ceilometer/trusty-updates

« back to all changes in this revision

Viewing changes to ceilometer/storage/impl_sqlalchemy.py

  • Committer: Package Import Robot
  • Author(s): Jorge Niedbalski
  • Date: 2015-07-14 08:18:13 UTC
  • mfrom: (25.1.8 trusty-proposed)
  • Revision ID: package-import@ubuntu.com-20150714081813-cw3mh2ry08mv9e1h
Tags: 2014.1.5-0ubuntu2
https://launchpad.net/bugs/1404076
0001-Optimize-resource-list-query.patch: Optimize resource list
query. (LP: #1404076).

Show diffs side-by-side

added added

removed removed

Lines of Context:
ceilometer/storage/impl_sqlalchemy.py
447
447
        if pagination:
448
448
            raise NotImplementedError('Pagination not implemented')
449
449
 
450
 
        def _apply_filters(query):
451
 
            #TODO(gordc) this should be merged with make_query_from_filter
452
 
            for column, value in [(models.Sample.resource_id, resource),
453
 
                                  (models.Sample.user_id, user),
454
 
                                  (models.Sample.project_id, project)]:
455
 
                if value:
456
 
                    query = query.filter(column == value)
457
 
            if source:
458
 
                query = query.filter(
459
 
                    models.Sample.sources.any(id=source))
460
 
            if metaquery:
461
 
                query = apply_metaquery_filter(session, query, metaquery)
462
 
            if start_timestamp:
463
 
                if start_timestamp_op == 'gt':
464
 
                    query = query.filter(
465
 
                        models.Sample.timestamp > start_timestamp)
466
 
                else:
467
 
                    query = query.filter(
468
 
                        models.Sample.timestamp >= start_timestamp)
469
 
            if end_timestamp:
470
 
                if end_timestamp_op == 'le':
471
 
                    query = query.filter(
472
 
                        models.Sample.timestamp <= end_timestamp)
473
 
                else:
474
 
                    query = query.filter(
475
 
                        models.Sample.timestamp < end_timestamp)
476
 
            return query
 
450
        s_filter = storage.SampleFilter(user=user,
 
451
                                        project=project,
 
452
                                        source=source,
 
453
                                        start_timestamp=start_timestamp,
 
454
                                        start_timestamp_op=start_timestamp_op,
 
455
                                        end_timestamp=end_timestamp,
 
456
                                        end_timestamp_op=end_timestamp_op,
 
457
                                        metaquery=metaquery,
 
458
                                        resource=resource)
477
459
 
478
460
        session = self._get_db_session()
479
461
        # get list of resource_ids
480
 
        res_q = session.query(distinct(models.Sample.resource_id))
481
 
        res_q = _apply_filters(res_q)
 
462
        res_q = session.query(distinct(models.Resource.resource_id)).join(
 
463
            models.Sample,
 
464
            models.Sample.resource_id == models.Resource.internal_id)
 
465
        res_q = make_query_from_filter(session, res_q, s_filter,
 
466
                                       require_meter=False)
482
467
 
483
468
        for res_id in res_q.all():
484
 
            # get latest Sample
485
 
            max_q = session.query(models.Sample)\
486
 
                .filter(models.Sample.resource_id == res_id[0])
487
 
            max_q = _apply_filters(max_q)
488
 
            max_q = max_q.order_by(models.Sample.timestamp.desc(),
489
 
                                   models.Sample.id.desc()).limit(1)
490
 
 
491
 
            # get the min timestamp value.
492
 
            min_q = session.query(models.Sample.timestamp)\
493
 
                .filter(models.Sample.resource_id == res_id[0])
494
 
            min_q = _apply_filters(min_q)
495
 
            min_q = min_q.order_by(models.Sample.timestamp.asc()).limit(1)
496
 
 
497
 
            sample = max_q.first()
498
 
            if sample:
499
 
                yield api_models.Resource(
500
 
                    resource_id=sample.resource_id,
501
 
                    project_id=sample.project_id,
502
 
                    first_sample_timestamp=min_q.first().timestamp,
503
 
                    last_sample_timestamp=sample.timestamp,
504
 
                    source=sample.sources[0].id,
505
 
                    user_id=sample.user_id,
506
 
                    metadata=sample.resource_metadata
507
 
                )
 
469
            # get max and min sample timestamp value
 
470
            min_max_q = (session.query(func.max(models.Sample.timestamp)
 
471
                                       .label('max_timestamp'),
 
472
                                       func.min(models.Sample.timestamp)
 
473
                                       .label('min_timestamp'))
 
474
                                .join(models.Resource,
 
475
                                      models.Resource.internal_id ==
 
476
                                      models.Sample.resource_id)
 
477
                                .filter(models.Resource.resource_id ==
 
478
                                        res_id[0]))
 
479
 
 
480
            min_max_q = make_query_from_filter(session, min_max_q, s_filter,
 
481
                                               require_meter=False)
 
482
 
 
483
            min_max = min_max_q.first()
 
484
 
 
485
            # get resource details for latest sample
 
486
            res_q = (session.query(models.Resource.resource_id,
 
487
                                   models.Resource.user_id,
 
488
                                   models.Resource.project_id,
 
489
                                   models.Resource.source_id,
 
490
                                   models.Resource.resource_metadata)
 
491
                            .join(models.Sample,
 
492
                                  models.Sample.resource_id ==
 
493
                                  models.Resource.internal_id)
 
494
                            .filter(models.Sample.timestamp ==
 
495
                                    min_max.max_timestamp)
 
496
                            .filter(models.Resource.resource_id ==
 
497
                                    res_id[0])
 
498
                            .order_by(models.Sample.id.desc()).limit(1))
 
499
 
 
500
            res = res_q.first()
 
501
 
 
502
            yield api_models.Resource(
 
503
                resource_id=res.resource_id,
 
504
                project_id=res.project_id,
 
505
                first_sample_timestamp=min_max.min_timestamp,
 
506
                last_sample_timestamp=min_max.max_timestamp,
 
507
                source=res.source_id,
 
508
                user_id=res.user_id,
 
509
                metadata=res.resource_metadata
 
510
            )
508
511
 
509
512
    def get_meters(self, user=None, project=None, resource=None, source=None,
510
513
                   metaquery={}, pagination=None):