('task.id', 'id'),

          ('task.state', 'state'),

          ('task.create_time', 'create_time'),

          ('task.start_time', 'start_time'),

          ('task.completion_time', 'completion_time'),

          ('task.channel_id', 'channel_id'),

          ('task.host_id', 'host_id'),

          ('task.parent', 'parent'),

          ('repo.task_id', 'task_id'),

          ('repo.create_event', 'create_event'),

          ('events.time', 'creation_time'),  # for compatibility with getRepo

          ('repo.tag_id', 'tag_id'),

          ('tag.name', 'tag_name'),

          ('repo.dist', 'dist'),

          ('repo.state', 'state'),

          ('repo.task_id', 'task_id'),

          ('repo.create_event', 'create_event'),

          ('repo.tag_id', 'tag_id'),

          ('repo.dist', 'dist'),

          ('tag.name', 'tag_name'),

                ('package.name', 'name'),

                ('volume.id', 'volume_id'), ('volume.name', 'volume_name'),

                ("package.name || '-' || build.version || '-' || build.release", 'nvr'),

                ('users.id', 'owner_id'), ('users.name', 'owner_name'),

                ('build.cg_id', 'cg_id'),

                ('build.source', 'source'),

                ('repo.id', 'repo_id'), ('repo.state', 'repo_state'),

                ('tag.id', 'tag_id'), ('tag.name', 'tag_name'),

                ('create_events.id', 'create_event_id'), ('create_events.time', 'create_event_time'),

                ('retire_events.id', 'retire_event_id'), ('retire_events.time', 'retire_event_time'),

                ('repo_create.id', 'repo_create_event_id'),

                ('repo_create.time', 'repo_create_event_time')]

      common_joined_fields = {

          'creator.name': 'creator_name',

          'revoker.name': 'revoker_name',

      }

      table_fields = {

          'user_perms': ['user_id', 'perm_id'],

                  clauses.append('ev1.time > %(after)s OR ev2.time > %(after)s')

                  fields['ev1.time > %(after)s'] = '_created_after'

                  fields['ev2.time > %(after)s'] = '_revoked_after'

              elif arg == 'afterEvent':

                  data['afterEvent'] = value

                  c_test = '%s.create_event > %%(afterEvent)i' % table

                      value = datetime.datetime.fromtimestamp(value).isoformat(' ')

                  data['before'] = value

                  clauses.append('ev1.time < %(before)s OR ev2.time < %(before)s')

                  fields['ev1.time < %(before)s'] = '_created_before'

                  fields['ev2.time < %(before)s'] = '_revoked_before'

              elif arg == 'beforeEvent':

          event_id2 = (_fetchSingle(q, {'archive_ids': build_archive_ids}) or (0,))[0] or 0

          event_id = max(event_id, event_id2)

      if event_id:

          ret['last_used'] = _singleValue(q, locals())

      else:

          ret['last_used'] = None

          """

          fields = ('id', 'ts')

          values = {'id': id}

          return _singleRow(q, values, fields, strict=True)

      def getLastEvent(self, before=None):

          """

          fields = ('id', 'ts')

          values = {}

          if before is not None:

              if not isinstance(before, NUMERIC_TYPES):

                  raise koji.GenericError('Invalid type for before: %s' % type(before))

              # use the repr() conversion because it retains more precision than the

              # string conversion

              values['before'] = before

          q += """ ORDER BY id DESC LIMIT 1"""

          return _singleRow(q, values, fields, strict=True)

                    ('build.extra', 'extra'),

                    ('events.id', 'creation_event_id'), ('events.time', 'creation_time'),

                    ('build.task_id', 'task_id'),

                    ('package.id', 'package_id'), ('package.name', 'package_name'),

                    ('package.name', 'name'),

                    ('volume.id', 'volume_id'), ('volume.name', 'volume_name'),

          if not packageID:

              return None

          st_complete = koji.BUILD_STATES['COMPLETE']

                       FROM build

                       JOIN events ON build.create_event = events.id

                       WHERE build.pkg_id = %(packageID)i

              id = get_tag_id(tag, strict=True)

          fields = ['repo.id', 'repo.state', 'repo.task_id', 'repo.create_event', 'events.time',

          aliases = ['id', 'state', 'task_id', 'create_event', 'creation_time', 'create_ts', 'dist']

          joins = ['events ON repo.create_event = events.id']

          clauses = ['repo.tag_id = %(id)i']

              'master': 'master',

              'start_time': 'start_time',

              'update_time': 'update_time',

              'user_id': 'user_id',

          }

          # sort for stability (unittests)

      def setUp(self):

          self.QueryProcessor = mock.patch('kojihub.QueryProcessor',

          self.queries = []

      def getQuery(self, *args, **kwargs):

          str(query)

          self.assertEqual(query.tables, ['repo'])

          columns = ['repo.id', 'repo.state', 'repo.task_id', 'repo.create_event',

          self.assertEqual(set(query.columns), set(columns))

          self.assertEqual(query.clauses, ['repo.state != %(st_deleted)s'])

          self.assertEqual(query.joins, ['tag ON repo.tag_id=tag.id',

          qp = QP(**kwargs)

          self.assertEqual(qp.tables, ['build'])

          self.assertEqual(qp.columns, ['build.id', 'build.completion_time',

                                        'events.id', 'events.time',

                                        'build.extra', 'package.name',

                                        "package.name || '-' || build.version || '-' || "

                                        "build.release", 'users.id', 'users.name', 'package.id',

                                        'package.name', 'build.release', 'build.source',

                                        'build.state', 'build.task_id', 'build.version',

                                        'volume.id', 'volume.name'])

          self.assertEqual(qp.clauses, ['package.id = %(packageID)i'])

          str(query)

          self.assertEqual(query.tables, ['repo'])

          columns = ['repo.id', 'repo.state', 'repo.task_id', 'repo.create_event',

          self.assertEqual(set(query.columns), set(columns))

          self.assertEqual(query.joins, ['events ON repo.create_event = events.id'])

          self.assertEqual(query.clauses, ['repo.dist is false', 'repo.state = %(state)s',

          str(query)

          self.assertEqual(query.tables, ['repo'])

          columns = ['repo.id', 'repo.state', 'repo.task_id', 'repo.create_event',

          self.assertEqual(set(query.columns), set(columns))

          self.assertEqual(query.joins, ['events ON repo.create_event = events.id'])

          self.assertEqual(query.clauses, ['create_event <= %(event)i', 'repo.dist is true',