def get_previsions(cls, session, end_date=None):
        """ Retrieve future validated requests per user """

        # Searching for requests with an timeframe
        #         [NOW()] ---------- ([end_date])?
        # exemples:
        #      <f --r1---- t>
        #                 <f --r2-- t>
        #                       <f ------r3-------- t>
        #      <f ----------- r4 -------------------- t>
        # => Matching period are periods ending after NOW()
        #   and if an end_date is specified periods starting before it:

        if end_date:
            future_requests = session.query(cls.user_id,func.sum(cls.days)).\
                                filter(cls.date_to >= func.current_timestamp(),
                                        cls.date_from < end_date,
                                       cls.vacation_type_id == 1,
                                       cls.status == 'APPROVED_ADMIN').\
                                    group_by(cls.user_id).\
                                    order_by(cls.user_id);
        else:
            future_requests = session.query(cls.user_id,func.sum(cls.days)).\
                                filter(cls.date_to >= func.current_timestamp(),
                                       cls.vacation_type_id == 1,
                                       cls.status == 'APPROVED_ADMIN').\
                                    group_by(cls.user_id).\
                                    order_by(cls.user_id);

        ret = {}
        for user_id, total in future_requests:
            ret[user_id] = total

        return ret

    def test_three(self):
        t = self.tables.t

        actual_ts = testing.db.scalar(func.current_timestamp()) - datetime.timedelta(days=5)
        self._test(
            func.current_timestamp() - datetime.timedelta(days=5),
            {"hour": actual_ts.hour, "year": actual_ts.year, "month": actual_ts.month},
        )

def add_ralert_to_to_database(session):
    for adven in ralert_to_add:
        print("Adventure Name: \'%s\', Type: \'%d\'" % (adven[0], adven[1]))
        new_alert = RescueAlert(adven[0],adven[1], func.current_timestamp(), func.current_timestamp())
        user = session.query(User).filter_by(email=adven[2]).first()
        user.rescue_alerts.append(new_alert)
        session.add(user)

    session.commit()

    def test_twelve(self):
        t = self.tables.t
        actual_ts = testing.db.scalar(func.current_timestamp()).replace(tzinfo=None) - datetime.datetime(
            2012, 5, 10, 12, 15, 25
        )

        self._test(
            func.current_timestamp() - func.coalesce(t.c.dtme, func.current_timestamp()), {"day": actual_ts.days}
        )

def valid_login(u_account):
    """Check if current login pass is acceptable.
    User can login by name, mobile or email.
    Returns a dict {id, name, privilege} if valid."""
    query_str = ''
    if u_account['name']:
        query_str = 'name="' + u_account['name'] + '"'
    elif u_account['mobile']:
        query_str = 'mobile="' + u_account['mobile'] + '"'
    elif u_account['email']:
        query_str = 'email="' + u_account['email'] + '"'
    if not query_str or not u_account['pwd']:
        #Error user info, return 1 is safe
        return '无效的用户名和密码格式'
    query_str += ' and passwd="' + u_account['pwd'] + '"'
    session = open_session()
    try:
        u = session.query(User).filter(query_str).first()
        if u == None:
            return '用户名或密码错误。'
        u.lastactive = func.current_timestamp()
        session.merge(u)
        session.commit()
        return {'id': u.id, 'name': u.name, 'privilege': u.privilege}
    except Exception, ex:
        print ex
        return '出错了，请重试。'

def get_dag_duration_info():
    '''get duration of currently running DagRuns
    :return dag_info
    '''
    driver = Session.bind.driver
    durations = {
        'pysqlite': func.sum(
            (func.julianday(func.current_timestamp()) - func.julianday(DagRun.start_date)) * 86400.0
        ),
        'mysqldb': func.sum(func.timestampdiff(text('second'), DagRun.start_date, func.now())),
        'default': func.sum(func.now() - DagRun.start_date)
    }
    duration = durations.get(driver, durations['default'])

    with session_scope(Session) as session:
        return session.query(
            DagRun.dag_id,
            DagRun.run_id,
            duration.label('duration')
        ).group_by(
            DagRun.dag_id,
            DagRun.run_id
        ).filter(
            DagRun.state == State.RUNNING
        ).all()

 def register_changes(self, memento_changes):
     """Create rows in the memento table
     :param memento_changes: an iterator over `memento_change` tuples that 
     need to be stored in the memento table.
     """
     rows = list()
     authentication_id = self._get_authentication_id()
     for m in memento_changes:
         if len(m.primary_key) == 1:
             rows.append(
                 {
                     "model": m.model,
                     "primary_key": m.primary_key[0],
                     "previous_attributes": m.previous_attributes,
                     "memento_type": self.memento_id_by_type.get(m.memento_type, None),
                     "authentication_id": authentication_id,
                 }
             )
     if len(rows):
         table = self._get_memento_table()
         clause = table.insert(creation_date=func.current_timestamp())
         try:
             clause.execute(rows)
         except exc.DatabaseError, e:
             LOGGER.error("Programming Error, could not flush history", exc_info=e)

    def test_compile(self):
        for dialect in all_dialects(exclude=("sybase",)):
            bindtemplate = BIND_TEMPLATES[dialect.paramstyle]
            self.assert_compile(
                func.current_timestamp(), "CURRENT_TIMESTAMP", dialect=dialect
            )
            self.assert_compile(func.localtime(), "LOCALTIME", dialect=dialect)
            if dialect.name in ("firebird",):
                self.assert_compile(
                    func.nosuchfunction(), "nosuchfunction", dialect=dialect
                )
            else:
                self.assert_compile(
                    func.nosuchfunction(), "nosuchfunction()", dialect=dialect
                )

            # test generic function compile
            class fake_func(GenericFunction):
                __return_type__ = sqltypes.Integer

                def __init__(self, arg, **kwargs):
                    GenericFunction.__init__(self, arg, **kwargs)

            self.assert_compile(
                fake_func("foo"),
                "fake_func(%s)"
                % bindtemplate
                % {"name": "fake_func_1", "position": 1},
                dialect=dialect,
            )

            functions._registry['_default'].pop('fake_func')

    def test_compile(self):
        for dialect in all_dialects(exclude=('sybase', )):
            bindtemplate = BIND_TEMPLATES[dialect.paramstyle]
            self.assert_compile(func.current_timestamp(),
                                "CURRENT_TIMESTAMP", dialect=dialect)
            self.assert_compile(func.localtime(), "LOCALTIME", dialect=dialect)
            if dialect.name in ('firebird',):
                self.assert_compile(func.nosuchfunction(),
                                    "nosuchfunction", dialect=dialect)
            else:
                self.assert_compile(func.nosuchfunction(),
                                    "nosuchfunction()", dialect=dialect)

            # test generic function compile
            class fake_func(GenericFunction):
                __return_type__ = sqltypes.Integer

                def __init__(self, arg, **kwargs):
                    GenericFunction.__init__(self, arg, **kwargs)

            self.assert_compile(
                fake_func('foo'),
                "fake_func(%s)" %
                bindtemplate % {'name': 'fake_func_1', 'position': 1},
                dialect=dialect)

    def disable(self, ends_at=None):
        if ends_at is None:
            ends_at = object_session(self).query(func.current_timestamp()).scalar()

        if self.begins_at is not None and self.begins_at > ends_at:
            self.ends_at = self.begins_at
        else:
            self.ends_at = ends_at

 def end_website_run(self, website_run_id):
     upd = ( self.website_run.update().
                 where(
                     self.website_run.c.website_run_id == website_run_id ).
                 values(
                     end_time=func.current_timestamp() )
           )
     result = self.conn.execute(upd)

def get_last_applied_membership_fee():
    """
    Get the last applied membership fee.
    :rtype: MembershipFee
    """
    return MembershipFee.q.filter(
        MembershipFee.ends_on <= func.current_timestamp()) \
        .order_by(MembershipFee.ends_on.desc()).first()

 def test_rename_column_serv_compiled_default(self):
     context = op_fixture('mysql')
     op.alter_column('t1', 'c1', new_column_name="c2", existing_type=Integer,
             existing_server_default=func.utc_thing(func.current_timestamp()))
     # this is not a valid MySQL default but the point is to just
     # test SQL expression rendering
     context.assert_(
         "ALTER TABLE t1 CHANGE c1 c2 INTEGER NULL DEFAULT utc_thing(CURRENT_TIMESTAMP)"
     )

    def test_constructor(self):
        try:
            func.current_timestamp('somearg')
            assert False
        except TypeError:
            assert True

        try:
            func.char_length('a', 'b')
            assert False
        except TypeError:
            assert True

        try:
            func.char_length()
            assert False
        except TypeError:
            assert True

def upgrade():
    print "... Create TABLE hebergement_video"
    op.create_table(
        'hebergement_video',
        Column('heb_vid_pk', Integer, primary_key=True, unique=True,
               nullable=False),
        Column('heb_vid_url', String()),
        Column('heb_vid_date', Date(), default=func.current_timestamp()),
        Column('heb_vid_heb_fk', Integer, ForeignKey('hebergement.heb_pk'))
    )

    def active(self, when=None):
        """
        Tests if the membership overlaps with a given interval. If no interval
        is given, it tests if the membership is active right now.
        :param Interval when: interval in which the membership
        :rtype: bool
        """
        if when is None:
            now = object_session(self).query(func.current_timestamp()).scalar()
            when = single(now)

        return when.overlaps(closed(self.begins_at, self.ends_at))

 def test_no_paren_fns(self):
     for fn, expected in [
         (func.uid(), "uid"),
         (func.UID(), "UID"),
         (func.sysdate(), "sysdate"),
         (func.row_number(), "row_number()"),
         (func.rank(), "rank()"),
         (func.now(), "CURRENT_TIMESTAMP"),
         (func.current_timestamp(), "CURRENT_TIMESTAMP"),
         (func.user(), "USER"),
     ]:
         self.assert_compile(fn, expected)

def play_with_time(session, name):
    user = session.query(User).filter_by(email='[email protected]').first()

    new_alert = RescueAlert(name, 
                            AdventureType.SnowBoarding.value, 
                            func.current_timestamp(), 
                            get_time_plus_minutes(30))
                            #func.current_timestamp().op('AT TIME ZONE')('UTC'))
                            #func.current_timestamp())
    user.rescue_alerts.append(new_alert)
    session.add(user)
    session.commit()

	def create_table(self):
		Table(
			OPLOG_TABLENAME,
			MetaData(bind = self.engine),
			Column('id', Integer, autoincrement=True, nullable=False, primary_key=True),
			Column('time', TIMESTAMP, default=func.current_timestamp(), nullable=False, index=True),
			Column('user', VARCHAR(32), nullable=False, index=True),
			Column('action', Text, nullable=False),
			Column('args', Text, nullable=True),
			Column('others', Text, nullable=True),
			mysql_engine = 'InnoDB',
			mysql_charset = 'utf8',
		).create(checkfirst = True)

    def _baseline_5_aggregates(self):
        Animal = self.metadata.tables["Animal"]
        Zoo = self.metadata.tables["Zoo"]

        # TODO: convert to ORM
        engine = self.metadata.bind
        for x in range(ITERATIONS):

            # views

            view = engine.execute(select([Animal.c.Legs])).fetchall()
            legs = sorted([x[0] for x in view])
            expected = {
                "Leopard": 73.5,
                "Slug": 0.75,
                "Tiger": None,
                "Lion": None,
                "Bear": None,
                "Ostrich": 103.2,
                "Centipede": None,
                "Emperor Penguin": None,
                "Adelie Penguin": None,
                "Millipede": None,
                "Ape": None,
                "Tick": None,
            }
            for species, lifespan in engine.execute(
                select([Animal.c.Species, Animal.c.Lifespan])
            ).fetchall():
                assert lifespan == expected[species]
            expected = ["Montr\xe9al Biod\xf4me", "Wild Animal Park"]
            e = select(
                [Zoo.c.Name],
                and_(
                    Zoo.c.Founded != None,  # noqa
                    Zoo.c.Founded <= func.current_timestamp(),
                    Zoo.c.Founded >= datetime.date(1990, 1, 1),
                ),
            )
            values = [val[0] for val in engine.execute(e).fetchall()]
            assert set(values) == set(expected)

            # distinct

            legs = [
                x[0]
                for x in engine.execute(
                    select([Animal.c.Legs], distinct=True)
                ).fetchall()
            ]
            legs.sort()