def update_most_viewed():
    query = QuestionViewHistory.query.filter_by(counted=False).distinct()
    question_count = query.count()
    frame_size = 1000
    counter = 0

    while counter <= question_count:
        all_questions = query.offset(counter*frame_size).limit(frame_size).all()
        counter = counter + frame_size

        for question in all_questions:
            most_viewed_question = MostViewedQuestion.query.filter_by(question_id=question.question_id).first()

            if most_viewed_question is None:
                most_viewed_question = MostViewedQuestion(question.question_id, question.view_count)
                db.session.add(most_viewed_question)
            else:
                most_viewed_question.view_count += question.view_count

            question.counted = True

        db.session.commit()

app = Flask(__name__)
db = SQLAlchemy(app)

class MostViewedQuestion(db.Model):
    __tablename__ = 'most_viewed_question'

    id = db.Column(db.Integer, primary_key=True)
    question_id = db.Column(db.Integer)
    view_count = db.Column(db.Integer)
    is_associated = db.Column(db.Boolean)
    can_be_associated = db.Column(db.Boolean)
    title = db.Column(db.String(500))
    body = db.Column(db.String(30000))
    tags = db.Column(db.String(500))
    last_update_date = db.Column(db.DateTime)

    def __init__(self, question_id, view_count, is_associated=False):
        self.question_id = question_id
        self.view_count = view_count
        self.is_associated = is_associated
        self.can_be_associated = True
        self.last_update_date = datetime.datetime.now()

    def __repr__(self):
        return '<MostViewedQuestion %s>' % str(self.id)

class QuestionViewHistory(db.Model):
    __tablename__ = 'question_view_history'

    id = db.Column(db.Integer, primary_key=True)
    question_id = db.Column(db.Integer)
    view_count = db.Column(db.Integer)
    view_date = db.Column(db.DateTime)
    counted = db.Column(db.Boolean)

    def __init__(self, question_id, view_count, view_date):
        self.question_id = question_id
        self.view_count = view_count
        self.view_date = view_date
        self.counted = False

    def __repr__(self):
        return '<QuestionViewHistory %s>' % str(self.id)

for question in all_questions:
    most_viewed_question = MostViewedQuestion.query.filter_by(question_id=question.question_id).first()

most_viewed_questions = MostViewedQuestion.query.filter_by(question_id.in_=questions)

from sqlalchemy import not_, select, exists

update_query = MostViewedQuestion.__table__.update().values(
            view_count=MostViewedQuestion.view_count + QuestionViewHistory.view_count
        ).where(and_(
                     MostViewedQuestion.question_id == QuestionViewHistory.question_id,
                     QuestionViewHistory.counted == True
        ))

UPDATE most_viewed_question SET view_count=(most_viewed_question.view_count + question_view_history.view_count)
FROM question_view_history
WHERE most_viewed_question.question_id = question_view_history.question_id
AND question_view_history.counted = true

insert_query = MostViewedQuestion.__table__.insert().
            from_select([MostViewedQuestion.question_id, MostViewedQuestion.view_count],
                     select([QuestionViewHistory.question_id, QuestionViewHistory.view_count]).
                     where(and_(not_(exists([MostViewedQuestion.question_id]).where(MostViewedQuestion.question_id == QuestionViewHistory.question_id)
                      ),  # WHERE ... AND ...
                            QuestionViewHistory.counted == True))
                      )

SESSION.execute(update_query)
SESSION.execute(insert_query)
SESSION.commit()

INSERT INTO most_viewed_question (question_id, view_count)
    SELECT question_view_history.question_id, question_view_history.view_count
    FROM question_view_history
    WHERE NOT (EXISTS (
        SELECT most_viewed_question.question_id
        FROM most_viewed_question
        WHERE most_viewed_question.question_id = question_view_history.question_id))
        AND question_view_history.counted = true

def update_most_viewed():
    reader_session = db_session()
    question_count = reader_session.query(func.count(QuestionViewHistory.id)).filter_by(counted=False).scalar()
    query = reader_session.query(QuestionViewHistory.id, QuestionViewHistory.question_id, QuestionViewHistory.view_count).filter_by(counted=False)
    frame_size = 1000
    progress_index = 0
    counter = 0

    print "Questions to update: %s, frame size: %s" % (question_count, frame_size)

    while counter <= question_count:
        all_questions = query.offset(0).limit(frame_size).all()
        counter = counter + frame_size

        wiriter_session = db_session()
        for question in all_questions:
            record_id, question_id, view_count = question
            most_viewed_question = wiriter_session.query(MostViewedQuestion).filter_by(question_id=question_id).first()
            if most_viewed_question is None:
                most_viewed_question = MostViewedQuestion(question_id, view_count)
                wiriter_session.add(most_viewed_question)
            else:
                most_viewed_question.view_count += view_count

            qh = wiriter_session.query(QuestionViewHistory).filter_by(id=record_id).first()
            qh.counted = True
            wiriter_session.add(qh)

            print_progress_bar(progress_index, question_count, prefix = 'Progress:', suffix = 'Complete')
            progress_index +=1

        wiriter_session.commit()
        wiriter_session.close()

    print "All questions were counted"

all_questions = query.offset(0).limit(frame_size).all()