PLDI 2019 Konure Code

This page contains program files discussed in the experimental results of our paper:

Using Active Learning to Synthesize Models of Applications That Access Databases

Jiasi Shen, Martin Rinard
PLDI 2019: Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation
Paper (pdf)

Contents

• Konure Regenerated Commands (Section 4.1)
  • Fulcrum Task Manager
  • Kandan Chat Room
  • Enki Blogging Application
  • Blog
  • Student Registration
• Synthetic Commands (Section 4.2)
  • Simple Sequences (SS)
  • Nested Conditionals (NC)
  • Unambiguous Long Reference Chains (UL)
  • Ambiguous Long Reference Chains (AL)
  • Ambiguous Short Reference Chains (AS)

Konure Regenerated Commands (Section 4.1)

Back to top

Fulcrum Task Manager

Back to top

Original Ruby on Rails application on Github: https://github.com/fulcrum-agile/fulcrum

def get_home (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`email` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': inputs[0]})
    outputs.extend(util.get_data(s0, 'users', 'email'))
    if util.has_rows(s0):
        s7 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': util.get_one_data(s0, 'users', 'id')})
        outputs.extend(util.get_data(s7, 'users', 'email'))
        s8 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s7, 'users', 'id')})
        outputs.extend(util.get_data(s8, 'projects', 'id'))
        outputs.extend(util.get_data(s8, 'projects', 'name'))
        outputs.extend(util.get_data(s8, 'projects', 'start_date'))
        s9 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': util.get_one_data(s7, 'users', 'id')})
        outputs.extend(util.get_data(s9, 'users', 'email'))
        s10 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s9, 'users', 'id')})
        outputs.extend(util.get_data(s10, 'projects', 'id'))
        outputs.extend(util.get_data(s10, 'projects', 'name'))
        outputs.extend(util.get_data(s10, 'projects', 'start_date'))
    else:
        pass
    return util.add_warnings(outputs)

def get_projects (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`email` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': inputs[0]})
    outputs.extend(util.get_data(s0, 'users', 'email'))
    if util.has_rows(s0):
        s7 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': util.get_one_data(s0, 'users', 'id')})
        outputs.extend(util.get_data(s7, 'users', 'email'))
        s8 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s7, 'users', 'id')})
        outputs.extend(util.get_data(s8, 'projects', 'id'))
        outputs.extend(util.get_data(s8, 'projects', 'name'))
        outputs.extend(util.get_data(s8, 'projects', 'start_date'))
        s9 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': util.get_one_data(s7, 'users', 'id')})
        outputs.extend(util.get_data(s9, 'users', 'email'))
        s10 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s9, 'users', 'id')})
        outputs.extend(util.get_data(s10, 'projects', 'id'))
        outputs.extend(util.get_data(s10, 'projects', 'name'))
        outputs.extend(util.get_data(s10, 'projects', 'start_date'))
    else:
        pass
    return util.add_warnings(outputs)

def get_projects_id (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`email` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': inputs[0]})
    if util.has_rows(s0):
        s8 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': util.get_one_data(s0, 'users', 'id')})
        s9 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s8, 'users', 'id')})
        s10 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': util.get_one_data(s8, 'users', 'id')})
        s11 = util.do_sql(conn, "SELECT  DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0 AND `projects`.`id` = :x1 LIMIT 1", {'x0': util.get_one_data(s10, 'users', 'id'), 'x1': inputs[1]})
        outputs.extend(util.get_data(s11, 'projects', 'id'))
        outputs.extend(util.get_data(s11, 'projects', 'name'))
        if util.has_rows(s11):
            s61 = util.do_sql(conn, "SELECT DISTINCT `users`.* FROM `users` INNER JOIN `projects_users` ON `users`.`id` = `projects_users`.`user_id` WHERE `projects_users`.`project_id` = :x0", {'x0': util.get_one_data(s11, 'projects', 'id')})
            outputs.extend(util.get_data(s61, 'users', 'id'))
            outputs.extend(util.get_data(s61, 'users', 'email'))
            outputs.extend(util.get_data(s61, 'users', 'name'))
            outputs.extend(util.get_data(s61, 'users', 'initials'))
            s62 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s10, 'users', 'id')})
            outputs.extend(util.get_data(s62, 'projects', 'id'))
            outputs.extend(util.get_data(s62, 'projects', 'name'))
        else:
            s12 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s10, 'users', 'id')})
    else:
        pass
    return util.add_warnings(outputs)

def get_projects_id_stories (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`email` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': inputs[0]})
    if util.has_rows(s0):
        s8 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': util.get_one_data(s0, 'users', 'id')})
        s9 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s8, 'users', 'id')})
        s10 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': util.get_one_data(s8, 'users', 'id')})
        s11 = util.do_sql(conn, "SELECT  DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0 AND `projects`.`id` = :x1 LIMIT 1", {'x0': util.get_one_data(s10, 'users', 'id'), 'x1': inputs[1]})
        if util.has_rows(s11):
            s46 = util.do_sql(conn, "SELECT `stories`.* FROM `stories`  WHERE `stories`.`project_id` IN (:x0)", {'x0': util.get_one_data(s11, 'projects', 'id')})
            outputs.extend(util.get_data(s46, 'stories', 'id'))
            outputs.extend(util.get_data(s46, 'stories', 'title'))
            outputs.extend(util.get_data(s46, 'stories', 'description'))
            outputs.extend(util.get_data(s46, 'stories', 'estimate'))
            outputs.extend(util.get_data(s46, 'stories', 'requested_by_id'))
            outputs.extend(util.get_data(s46, 'stories', 'owned_by_id'))
            outputs.extend(util.get_data(s46, 'stories', 'project_id'))
            if util.has_rows(s46):
                s62 = util.do_sql(conn, "SELECT `notes`.* FROM `notes`  WHERE `notes`.`story_id` IN (:x0)", {'x0': util.get_one_data(s46, 'stories', 'id')})
                outputs.extend(util.get_data(s62, 'notes', 'id'))
                outputs.extend(util.get_data(s62, 'notes', 'note'))
                outputs.extend(util.get_data(s62, 'notes', 'user_id'))
                outputs.extend(util.get_data(s62, 'notes', 'story_id'))
            else:
                pass
        else:
            s12 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s10, 'users', 'id')})
    else:
        pass
    return util.add_warnings(outputs)

def get_projects_id_stories_id (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`email` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': inputs[0]})
    if util.has_rows(s0):
        s8 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': util.get_one_data(s0, 'users', 'id')})
        s9 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s8, 'users', 'id')})
        s10 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': util.get_one_data(s8, 'users', 'id')})
        s11 = util.do_sql(conn, "SELECT  DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0 AND `projects`.`id` = :x1 LIMIT 1", {'x0': util.get_one_data(s10, 'users', 'id'), 'x1': inputs[1]})
        if util.has_rows(s11):
            s47 = util.do_sql(conn, "SELECT  `stories`.* FROM `stories`  WHERE `stories`.`project_id` = :x0 AND `stories`.`id` = :x1 LIMIT 1", {'x0': util.get_one_data(s11, 'projects', 'id'), 'x1': inputs[2]})
            outputs.extend(util.get_data(s47, 'stories', 'id'))
            outputs.extend(util.get_data(s47, 'stories', 'title'))
            outputs.extend(util.get_data(s47, 'stories', 'description'))
            outputs.extend(util.get_data(s47, 'stories', 'estimate'))
            outputs.extend(util.get_data(s47, 'stories', 'requested_by_id'))
            outputs.extend(util.get_data(s47, 'stories', 'owned_by_id'))
            outputs.extend(util.get_data(s47, 'stories', 'project_id'))
            if util.has_rows(s47):
                s64 = util.do_sql(conn, "SELECT `notes`.* FROM `notes`  WHERE `notes`.`story_id` = :x0", {'x0': util.get_one_data(s47, 'stories', 'id')})
                outputs.extend(util.get_data(s64, 'notes', 'id'))
                outputs.extend(util.get_data(s64, 'notes', 'note'))
                outputs.extend(util.get_data(s64, 'notes', 'user_id'))
                outputs.extend(util.get_data(s64, 'notes', 'story_id'))
            else:
                s48 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s10, 'users', 'id')})
        else:
            s12 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s10, 'users', 'id')})
    else:
        pass
    return util.add_warnings(outputs)

def get_projects_id_stories_id_notes (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`email` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': inputs[0]})
    if util.has_rows(s0):
        s8 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': util.get_one_data(s0, 'users', 'id')})
        s9 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s8, 'users', 'id')})
        s10 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': util.get_one_data(s8, 'users', 'id')})
        s11 = util.do_sql(conn, "SELECT  DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0 AND `projects`.`id` = :x1 LIMIT 1", {'x0': util.get_one_data(s10, 'users', 'id'), 'x1': inputs[1]})
        if util.has_rows(s11):
            s47 = util.do_sql(conn, "SELECT  `stories`.* FROM `stories`  WHERE `stories`.`project_id` = :x0 AND `stories`.`id` = :x1 LIMIT 1", {'x0': util.get_one_data(s11, 'projects', 'id'), 'x1': inputs[2]})
            if util.has_rows(s47):
                s57 = util.do_sql(conn, "SELECT `notes`.* FROM `notes`  WHERE `notes`.`story_id` = :x0", {'x0': util.get_one_data(s47, 'stories', 'id')})
                outputs.extend(util.get_data(s57, 'notes', 'id'))
                outputs.extend(util.get_data(s57, 'notes', 'note'))
                outputs.extend(util.get_data(s57, 'notes', 'user_id'))
                outputs.extend(util.get_data(s57, 'notes', 'story_id'))
            else:
                s48 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s10, 'users', 'id')})
        else:
            s12 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s10, 'users', 'id')})
    else:
        pass
    return util.add_warnings(outputs)

def get_projects_id_stories_id_notes_id (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`email` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': inputs[0]})
    if util.has_rows(s0):
        s8 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': util.get_one_data(s0, 'users', 'id')})
        s9 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s8, 'users', 'id')})
        s10 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': util.get_one_data(s8, 'users', 'id')})
        s11 = util.do_sql(conn, "SELECT  DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0 AND `projects`.`id` = :x1 LIMIT 1", {'x0': util.get_one_data(s10, 'users', 'id'), 'x1': inputs[1]})
        if util.has_rows(s11):
            s47 = util.do_sql(conn, "SELECT  `stories`.* FROM `stories`  WHERE `stories`.`project_id` = :x0 AND `stories`.`id` = :x1 LIMIT 1", {'x0': util.get_one_data(s11, 'projects', 'id'), 'x1': inputs[2]})
            if util.has_rows(s47):
                s57 = util.do_sql(conn, "SELECT  `notes`.* FROM `notes`  WHERE `notes`.`story_id` = :x0 AND `notes`.`id` = :x1 LIMIT 1", {'x0': util.get_one_data(s47, 'stories', 'id'), 'x1': inputs[3]})
                outputs.extend(util.get_data(s57, 'notes', 'id'))
                outputs.extend(util.get_data(s57, 'notes', 'note'))
                outputs.extend(util.get_data(s57, 'notes', 'user_id'))
                outputs.extend(util.get_data(s57, 'notes', 'story_id'))
                if util.has_rows(s57):
                    pass
                else:
                    s58 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s10, 'users', 'id')})
            else:
                s48 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s10, 'users', 'id')})
        else:
            s12 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s10, 'users', 'id')})
    else:
        pass
    return util.add_warnings(outputs)

def get_projects_id_users (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`email` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': inputs[0]})
    if util.has_rows(s0):
        s8 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': util.get_one_data(s0, 'users', 'id')})
        s9 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s8, 'users', 'id')})
        s10 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0  ORDER BY `users`.`id` ASC LIMIT 1", {'x0': util.get_one_data(s8, 'users', 'id')})
        s11 = util.do_sql(conn, "SELECT  DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0 AND `projects`.`id` = :x1 LIMIT 1", {'x0': util.get_one_data(s10, 'users', 'id'), 'x1': inputs[1]})
        outputs.extend(util.get_data(s11, 'projects', 'id'))
        outputs.extend(util.get_data(s11, 'projects', 'name'))
        if util.has_rows(s11):
            s61 = util.do_sql(conn, "SELECT DISTINCT `users`.* FROM `users` INNER JOIN `projects_users` ON `users`.`id` = `projects_users`.`user_id` WHERE `projects_users`.`project_id` = :x0", {'x0': util.get_one_data(s11, 'projects', 'id')})
            outputs.extend(util.get_data(s61, 'users', 'id'))
            outputs.extend(util.get_data(s61, 'users', 'email'))
            outputs.extend(util.get_data(s61, 'users', 'name'))
            outputs.extend(util.get_data(s61, 'users', 'initials'))
            s62 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s10, 'users', 'id')})
            outputs.extend(util.get_data(s62, 'projects', 'id'))
            outputs.extend(util.get_data(s62, 'projects', 'name'))
        else:
            s12 = util.do_sql(conn, "SELECT DISTINCT `projects`.* FROM `projects` INNER JOIN `projects_users` ON `projects`.`id` = `projects_users`.`project_id` WHERE `projects_users`.`user_id` = :x0", {'x0': util.get_one_data(s10, 'users', 'id')})
    else:
        pass
    return util.add_warnings(outputs)

Kandan Chat Room

Back to top

Original Ruby on Rails application on Github: https://github.com/kandanapp/kandan

def get_channels (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`username` = :x0 LIMIT 1", {'x0': inputs[0]})
    if util.has_rows(s0):
        s2 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s0, 'users', 'id')})
        s3 = util.do_sql(conn, "SELECT `channels`.* FROM `channels`", {})
        outputs.extend(util.get_data(s3, 'channels', 'id'))
        outputs.extend(util.get_data(s3, 'channels', 'name'))
        outputs.extend(util.get_data(s3, 'channels', 'user_id'))
        if util.has_rows(s3):
            s4 = util.do_sql(conn, "SELECT `activities`.* FROM `activities`  WHERE `activities`.`channel_id` IN :x0", {'x0': util.get_data(s3, 'channels', 'id')})
            outputs.extend(util.get_data(s4, 'activities', 'id'))
            outputs.extend(util.get_data(s4, 'activities', 'content'))
            outputs.extend(util.get_data(s4, 'activities', 'channel_id'))
            outputs.extend(util.get_data(s4, 'activities', 'user_id'))
            if util.has_rows(s4):
                s71 = util.do_sql(conn, "SELECT `users`.* FROM `users`  WHERE `users`.`id` IN :x0", {'x0': util.get_data(s4, 'activities', 'user_id')})
                outputs.extend(util.get_data(s71, 'users', 'id'))
                outputs.extend(util.get_data(s71, 'users', 'email'))
                outputs.extend(util.get_data(s71, 'users', 'first_name'))
                outputs.extend(util.get_data(s71, 'users', 'last_name'))
                outputs.extend(util.get_data(s71, 'users', 'username'))
                s72 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s2, 'users', 'id')})
                s73 = util.do_sql(conn, "SELECT `channels`.* FROM `channels`", {})
                outputs.extend(util.get_data(s73, 'channels', 'id'))
                outputs.extend(util.get_data(s73, 'channels', 'name'))
                outputs.extend(util.get_data(s73, 'channels', 'user_id'))
                s73_all = s73
                for s73 in s73_all:
                    s74 = util.do_sql(conn, "SELECT COUNT(*) FROM `activities`  WHERE `activities`.`channel_id` = :x0", {'x0': util.get_one_data(s73, 'channels', 'id')})
                    s75 = util.do_sql(conn, "SELECT  `activities`.* FROM `activities`  WHERE `activities`.`channel_id` = :x0 ORDER BY id DESC LIMIT 30 OFFSET 0", {'x0': util.get_one_data(s73, 'channels', 'id')})
                    outputs.extend(util.get_data(s75, 'activities', 'id'))
                    outputs.extend(util.get_data(s75, 'activities', 'content'))
                    outputs.extend(util.get_data(s75, 'activities', 'channel_id'))
                    outputs.extend(util.get_data(s75, 'activities', 'user_id'))
                    if util.has_rows(s75):
                        s78 = util.do_sql(conn, "SELECT `users`.* FROM `users`  WHERE `users`.`id` IN :x0", {'x0': util.get_data(s75, 'activities', 'user_id')})
                        outputs.extend(util.get_data(s78, 'users', 'id'))
                        outputs.extend(util.get_data(s78, 'users', 'email'))
                        outputs.extend(util.get_data(s78, 'users', 'first_name'))
                        outputs.extend(util.get_data(s78, 'users', 'last_name'))
                        outputs.extend(util.get_data(s78, 'users', 'username'))
                    else:
                        pass
                s73 = s73_all
            else:
                s5 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s2, 'users', 'id')})
                s6 = util.do_sql(conn, "SELECT `channels`.* FROM `channels`", {})
                outputs.extend(util.get_data(s6, 'channels', 'id'))
                outputs.extend(util.get_data(s6, 'channels', 'name'))
                outputs.extend(util.get_data(s6, 'channels', 'user_id'))
                s6_all = s6
                for s6 in s6_all:
                    s7 = util.do_sql(conn, "SELECT COUNT(*) FROM `activities`  WHERE `activities`.`channel_id` = :x0", {'x0': util.get_one_data(s6, 'channels', 'id')})
                    s8 = util.do_sql(conn, "SELECT  `activities`.* FROM `activities`  WHERE `activities`.`channel_id` = :x0 ORDER BY id DESC LIMIT 30 OFFSET 0", {'x0': util.get_one_data(s6, 'channels', 'id')})
                s6 = s6_all
        else:
            s36 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s2, 'users', 'id')})
            s37 = util.do_sql(conn, "SELECT `channels`.* FROM `channels`", {})
    else:
        pass
    return util.add_warnings(outputs)

def get_channels_id_activities (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`username` = :x0 LIMIT 1", {'x0': inputs[0]})
    if util.has_rows(s0):
        s2 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s0, 'users', 'id')})
        s3 = util.do_sql(conn, "SELECT `channels`.* FROM `channels`", {})
        if util.has_rows(s3):
            s4 = util.do_sql(conn, "SELECT `activities`.* FROM `activities`  WHERE `activities`.`channel_id` IN :x0", {'x0': util.get_data(s3, 'channels', 'id')})
            if util.has_rows(s4):
                s40 = util.do_sql(conn, "SELECT `users`.* FROM `users`  WHERE `users`.`id` IN :x0", {'x0': util.get_data(s4, 'activities', 'user_id')})
                s41 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s2, 'users', 'id')})
                s42 = util.do_sql(conn, "SELECT  `channels`.* FROM `channels`  WHERE `channels`.`id` = :x0 LIMIT 1", {'x0': inputs[1]})
                if util.has_rows(s42):
                    s132 = util.do_sql(conn, "SELECT  `activities`.* FROM `activities`  WHERE `activities`.`channel_id` = :x0 ORDER BY id LIMIT 1", {'x0': util.get_one_data(s42, 'channels', 'id')})
                    outputs.extend(util.get_data(s132, 'activities', 'id'))
                    outputs.extend(util.get_data(s132, 'activities', 'content'))
                    outputs.extend(util.get_data(s132, 'activities', 'channel_id'))
                    outputs.extend(util.get_data(s132, 'activities', 'user_id'))
                    s133 = util.do_sql(conn, "SELECT  `activities`.* FROM `activities`  WHERE `activities`.`channel_id` = :x0 ORDER BY id DESC LIMIT 30", {'x0': util.get_one_data(s42, 'channels', 'id')})
                    outputs.extend(util.get_data(s133, 'activities', 'id'))
                    outputs.extend(util.get_data(s133, 'activities', 'content'))
                    outputs.extend(util.get_data(s133, 'activities', 'channel_id'))
                    outputs.extend(util.get_data(s133, 'activities', 'user_id'))
                    if util.has_rows(s133):
                        s167 = util.do_sql(conn, "SELECT `users`.* FROM `users`  WHERE `users`.`id` IN :x0", {'x0': util.get_data(s133, 'activities', 'user_id')})
                        outputs.extend(util.get_data(s167, 'users', 'id'))
                        outputs.extend(util.get_data(s167, 'users', 'email'))
                        outputs.extend(util.get_data(s167, 'users', 'first_name'))
                        outputs.extend(util.get_data(s167, 'users', 'last_name'))
                        outputs.extend(util.get_data(s167, 'users', 'username'))
                    else:
                        pass
                else:
                    pass
            else:
                s5 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s2, 'users', 'id')})
                s6 = util.do_sql(conn, "SELECT  `channels`.* FROM `channels`  WHERE `channels`.`id` = :x0 LIMIT 1", {'x0': inputs[1]})
                if util.has_rows(s6):
                    s69 = util.do_sql(conn, "SELECT  `activities`.* FROM `activities`  WHERE `activities`.`channel_id` = :x0 ORDER BY id LIMIT 1", {'x0': util.get_one_data(s6, 'channels', 'id')})
                    s70 = util.do_sql(conn, "SELECT  `activities`.* FROM `activities`  WHERE `activities`.`channel_id` = :x0 ORDER BY id DESC LIMIT 30", {'x0': util.get_one_data(s6, 'channels', 'id')})
                else:
                    pass
        else:
            s25 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s2, 'users', 'id')})
            s26 = util.do_sql(conn, "SELECT  `channels`.* FROM `channels`  WHERE `channels`.`id` = :x0 LIMIT 1", {'x0': inputs[1]})
    else:
        pass
    return util.add_warnings(outputs)

def get_channels_id_activities_id (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`username` = :x0 LIMIT 1", {'x0': inputs[0]})
    if util.has_rows(s0):
        s2 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s0, 'users', 'id')})
        s3 = util.do_sql(conn, "SELECT `channels`.* FROM `channels`", {})
        if util.has_rows(s3):
            s4 = util.do_sql(conn, "SELECT `activities`.* FROM `activities`  WHERE `activities`.`channel_id` IN :x0", {'x0': util.get_data(s3, 'channels', 'id')})
            if util.has_rows(s4):
                s47 = util.do_sql(conn, "SELECT `users`.* FROM `users`  WHERE `users`.`id` IN :x0", {'x0': util.get_data(s4, 'activities', 'user_id')})
                s48 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s2, 'users', 'id')})
                s49 = util.do_sql(conn, "SELECT  `activities`.* FROM `activities`  WHERE `activities`.`id` = :x0 LIMIT 1", {'x0': inputs[2]})
                outputs.extend(util.get_data(s49, 'activities', 'content'))
            else:
                s5 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s2, 'users', 'id')})
                s6 = util.do_sql(conn, "SELECT  `activities`.* FROM `activities`  WHERE `activities`.`id` = :x0 LIMIT 1", {'x0': inputs[2]})
                outputs.extend(util.get_data(s6, 'activities', 'content'))
        else:
            s25 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s2, 'users', 'id')})
            s26 = util.do_sql(conn, "SELECT  `activities`.* FROM `activities`  WHERE `activities`.`id` = :x0 LIMIT 1", {'x0': inputs[2]})
            outputs.extend(util.get_data(s26, 'activities', 'content'))
    else:
        pass
    return util.add_warnings(outputs)

def get_me (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`username` = :x0 LIMIT 1", {'x0': inputs[0]})
    outputs.extend(util.get_data(s0, 'users', 'id'))
    outputs.extend(util.get_data(s0, 'users', 'email'))
    outputs.extend(util.get_data(s0, 'users', 'first_name'))
    outputs.extend(util.get_data(s0, 'users', 'last_name'))
    outputs.extend(util.get_data(s0, 'users', 'username'))
    if util.has_rows(s0):
        s2 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s0, 'users', 'id')})
        outputs.extend(util.get_data(s2, 'users', 'id'))
        outputs.extend(util.get_data(s2, 'users', 'email'))
        outputs.extend(util.get_data(s2, 'users', 'first_name'))
        outputs.extend(util.get_data(s2, 'users', 'last_name'))
        outputs.extend(util.get_data(s2, 'users', 'username'))
        s3 = util.do_sql(conn, "SELECT `channels`.* FROM `channels`", {})
        if util.has_rows(s3):
            s4 = util.do_sql(conn, "SELECT `activities`.* FROM `activities`  WHERE `activities`.`channel_id` IN :x0", {'x0': util.get_data(s3, 'channels', 'id')})
            if util.has_rows(s4):
                s35 = util.do_sql(conn, "SELECT `users`.* FROM `users`  WHERE `users`.`id` IN :x0", {'x0': util.get_data(s4, 'activities', 'user_id')})
                s36 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s2, 'users', 'id')})
                outputs.extend(util.get_data(s36, 'users', 'id'))
                outputs.extend(util.get_data(s36, 'users', 'email'))
                outputs.extend(util.get_data(s36, 'users', 'first_name'))
                outputs.extend(util.get_data(s36, 'users', 'last_name'))
                outputs.extend(util.get_data(s36, 'users', 'username'))
            else:
                s5 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s2, 'users', 'id')})
                outputs.extend(util.get_data(s5, 'users', 'id'))
                outputs.extend(util.get_data(s5, 'users', 'email'))
                outputs.extend(util.get_data(s5, 'users', 'first_name'))
                outputs.extend(util.get_data(s5, 'users', 'last_name'))
                outputs.extend(util.get_data(s5, 'users', 'username'))
        else:
            s22 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s2, 'users', 'id')})
            outputs.extend(util.get_data(s22, 'users', 'id'))
            outputs.extend(util.get_data(s22, 'users', 'email'))
            outputs.extend(util.get_data(s22, 'users', 'first_name'))
            outputs.extend(util.get_data(s22, 'users', 'last_name'))
            outputs.extend(util.get_data(s22, 'users', 'username'))
    else:
        pass
    return util.add_warnings(outputs)

def get_users (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`username` = :x0 LIMIT 1", {'x0': inputs[0]})
    outputs.extend(util.get_data(s0, 'users', 'id'))
    outputs.extend(util.get_data(s0, 'users', 'email'))
    outputs.extend(util.get_data(s0, 'users', 'first_name'))
    outputs.extend(util.get_data(s0, 'users', 'last_name'))
    outputs.extend(util.get_data(s0, 'users', 'username'))
    if util.has_rows(s0):
        s8 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s0, 'users', 'id')})
        outputs.extend(util.get_data(s8, 'users', 'id'))
        outputs.extend(util.get_data(s8, 'users', 'email'))
        outputs.extend(util.get_data(s8, 'users', 'first_name'))
        outputs.extend(util.get_data(s8, 'users', 'last_name'))
        outputs.extend(util.get_data(s8, 'users', 'username'))
        s9 = util.do_sql(conn, "SELECT `channels`.* FROM `channels`", {})
        if util.has_rows(s9):
            s10 = util.do_sql(conn, "SELECT `activities`.* FROM `activities`  WHERE `activities`.`channel_id` IN :x0", {'x0': util.get_data(s9, 'channels', 'id')})
            if util.has_rows(s10):
                s58 = util.do_sql(conn, "SELECT `users`.* FROM `users`  WHERE `users`.`id` IN :x0", {'x0': util.get_data(s10, 'activities', 'user_id')})
                outputs.extend(util.get_data(s58, 'users', 'id'))
                outputs.extend(util.get_data(s58, 'users', 'email'))
                outputs.extend(util.get_data(s58, 'users', 'first_name'))
                outputs.extend(util.get_data(s58, 'users', 'last_name'))
                outputs.extend(util.get_data(s58, 'users', 'username'))
                s59 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s8, 'users', 'id')})
                outputs.extend(util.get_data(s59, 'users', 'id'))
                outputs.extend(util.get_data(s59, 'users', 'email'))
                outputs.extend(util.get_data(s59, 'users', 'first_name'))
                outputs.extend(util.get_data(s59, 'users', 'last_name'))
                outputs.extend(util.get_data(s59, 'users', 'username'))
                s60 = util.do_sql(conn, "SELECT `users`.* FROM `users`", {})
                outputs.extend(util.get_data(s60, 'users', 'id'))
                outputs.extend(util.get_data(s60, 'users', 'email'))
                outputs.extend(util.get_data(s60, 'users', 'first_name'))
                outputs.extend(util.get_data(s60, 'users', 'last_name'))
                outputs.extend(util.get_data(s60, 'users', 'username'))
            else:
                s11 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s8, 'users', 'id')})
                outputs.extend(util.get_data(s11, 'users', 'id'))
                outputs.extend(util.get_data(s11, 'users', 'email'))
                outputs.extend(util.get_data(s11, 'users', 'first_name'))
                outputs.extend(util.get_data(s11, 'users', 'last_name'))
                outputs.extend(util.get_data(s11, 'users', 'username'))
                s12 = util.do_sql(conn, "SELECT `users`.* FROM `users`", {})
                outputs.extend(util.get_data(s12, 'users', 'id'))
                outputs.extend(util.get_data(s12, 'users', 'email'))
                outputs.extend(util.get_data(s12, 'users', 'first_name'))
                outputs.extend(util.get_data(s12, 'users', 'last_name'))
                outputs.extend(util.get_data(s12, 'users', 'username'))
        else:
            s36 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s8, 'users', 'id')})
            outputs.extend(util.get_data(s36, 'users', 'id'))
            outputs.extend(util.get_data(s36, 'users', 'email'))
            outputs.extend(util.get_data(s36, 'users', 'first_name'))
            outputs.extend(util.get_data(s36, 'users', 'last_name'))
            outputs.extend(util.get_data(s36, 'users', 'username'))
            s37 = util.do_sql(conn, "SELECT `users`.* FROM `users`", {})
            outputs.extend(util.get_data(s37, 'users', 'id'))
            outputs.extend(util.get_data(s37, 'users', 'email'))
            outputs.extend(util.get_data(s37, 'users', 'first_name'))
            outputs.extend(util.get_data(s37, 'users', 'last_name'))
            outputs.extend(util.get_data(s37, 'users', 'username'))
    else:
        pass
    return util.add_warnings(outputs)

def get_users_id (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`username` = :x0 LIMIT 1", {'x0': inputs[0]})
    outputs.extend(util.get_data(s0, 'users', 'id'))
    outputs.extend(util.get_data(s0, 'users', 'email'))
    outputs.extend(util.get_data(s0, 'users', 'first_name'))
    outputs.extend(util.get_data(s0, 'users', 'last_name'))
    outputs.extend(util.get_data(s0, 'users', 'username'))
    if util.has_rows(s0):
        s2 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s0, 'users', 'id')})
        outputs.extend(util.get_data(s2, 'users', 'id'))
        outputs.extend(util.get_data(s2, 'users', 'email'))
        outputs.extend(util.get_data(s2, 'users', 'first_name'))
        outputs.extend(util.get_data(s2, 'users', 'last_name'))
        outputs.extend(util.get_data(s2, 'users', 'username'))
        s3 = util.do_sql(conn, "SELECT `channels`.* FROM `channels`", {})
        if util.has_rows(s3):
            s4 = util.do_sql(conn, "SELECT `activities`.* FROM `activities`  WHERE `activities`.`channel_id` IN :x0", {'x0': util.get_data(s3, 'channels', 'id')})
            if util.has_rows(s4):
                s35 = util.do_sql(conn, "SELECT `users`.* FROM `users`  WHERE `users`.`id` IN :x0", {'x0': util.get_data(s4, 'activities', 'user_id')})
                s36 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s2, 'users', 'id')})
                outputs.extend(util.get_data(s36, 'users', 'id'))
                outputs.extend(util.get_data(s36, 'users', 'email'))
                outputs.extend(util.get_data(s36, 'users', 'first_name'))
                outputs.extend(util.get_data(s36, 'users', 'last_name'))
                outputs.extend(util.get_data(s36, 'users', 'username'))
            else:
                s5 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s2, 'users', 'id')})
                outputs.extend(util.get_data(s5, 'users', 'id'))
                outputs.extend(util.get_data(s5, 'users', 'email'))
                outputs.extend(util.get_data(s5, 'users', 'first_name'))
                outputs.extend(util.get_data(s5, 'users', 'last_name'))
                outputs.extend(util.get_data(s5, 'users', 'username'))
        else:
            s22 = util.do_sql(conn, "SELECT  `users`.* FROM `users`  WHERE `users`.`id` = :x0 LIMIT 1", {'x0': util.get_one_data(s2, 'users', 'id')})
            outputs.extend(util.get_data(s22, 'users', 'id'))
            outputs.extend(util.get_data(s22, 'users', 'email'))
            outputs.extend(util.get_data(s22, 'users', 'first_name'))
            outputs.extend(util.get_data(s22, 'users', 'last_name'))
            outputs.extend(util.get_data(s22, 'users', 'username'))
    else:
        pass
    return util.add_warnings(outputs)

Enki Blogging Application

Back to top

Original Ruby on Rails application on Github: https://github.com/xaviershay/enki

def get_admin_comments_id (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT  `comments`.* FROM `comments` WHERE `comments`.`id` = :x0 LIMIT 1", {'x0': inputs[0]})
    outputs.extend(util.get_data(s0, 'comments', 'id'))
    outputs.extend(util.get_data(s0, 'comments', 'author'))
    outputs.extend(util.get_data(s0, 'comments', 'author_url'))
    outputs.extend(util.get_data(s0, 'comments', 'author_email'))
    outputs.extend(util.get_data(s0, 'comments', 'body'))
    return util.add_warnings(outputs)

def get_admin_pages (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT COUNT(*) FROM `pages`", {})
    if util.has_rows(s0):
        s2 = util.do_sql(conn, "SELECT  `pages`.* FROM `pages`  ORDER BY created_at DESC LIMIT 30 OFFSET 0", {})
        outputs.extend(util.get_data(s2, 'pages', 'id'))
        outputs.extend(util.get_data(s2, 'pages', 'title'))
        outputs.extend(util.get_data(s2, 'pages', 'slug'))
        outputs.extend(util.get_data(s2, 'pages', 'body'))
    else:
        pass
    return util.add_warnings(outputs)

def get_admin_pages_id (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT  `pages`.* FROM `pages` WHERE `pages`.`id` = :x0 LIMIT 1", {'x0': inputs[0]})
    outputs.extend(util.get_data(s0, 'pages', 'id'))
    outputs.extend(util.get_data(s0, 'pages', 'title'))
    outputs.extend(util.get_data(s0, 'pages', 'slug'))
    outputs.extend(util.get_data(s0, 'pages', 'body'))
    return util.add_warnings(outputs)

def get_admin_posts (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT COUNT(*) FROM `posts`", {})
    if util.has_rows(s0):
        s2 = util.do_sql(conn, "SELECT  `posts`.* FROM `posts`  ORDER BY coalesce(published_at, updated_at) DESC LIMIT 30 OFFSET 0", {})
        outputs.extend(util.get_data(s2, 'posts', 'id'))
        outputs.extend(util.get_data(s2, 'posts', 'title'))
        outputs.extend(util.get_data(s2, 'posts', 'body'))
        s2_all = s2
        for s2 in s2_all:
            s3 = util.do_sql(conn, "SELECT COUNT(*) FROM `comments` WHERE `comments`.`post_id` = :x0", {'x0': util.get_one_data(s2, 'posts', 'id')})
        s2 = s2_all
    else:
        pass
    return util.add_warnings(outputs)

Blog

Back to top

Original Ruby on Rails example application: https://guides.rubyonrails.org/getting_started.html

def get_article_id (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT `articles`.* FROM `articles`", {})
    s1 = util.do_sql(conn, "SELECT  `articles`.* FROM `articles` WHERE `articles`.`id` = :x0 LIMIT 1", {'x0': inputs[0]})
    outputs.extend(util.get_data(s1, 'articles', 'id'))
    outputs.extend(util.get_data(s1, 'articles', 'title'))
    outputs.extend(util.get_data(s1, 'articles', 'text'))
    if util.has_rows(s1):
        s9 = util.do_sql(conn, "SELECT `comments`.* FROM `comments` WHERE `comments`.`article_id` = :x0", {'x0': util.get_one_data(s1, 'articles', 'id')})
        outputs.extend(util.get_data(s9, 'comments', 'commenter'))
        outputs.extend(util.get_data(s9, 'comments', 'body'))
        outputs.extend(util.get_data(s9, 'comments', 'article_id'))
    else:
        pass
    return util.add_warnings(outputs)

def get_articles (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT `articles`.* FROM `articles`", {})
    outputs.extend(util.get_data(s0, 'articles', 'id'))
    outputs.extend(util.get_data(s0, 'articles', 'title'))
    outputs.extend(util.get_data(s0, 'articles', 'text'))
    s1 = util.do_sql(conn, "SELECT `articles`.* FROM `articles`", {})
    outputs.extend(util.get_data(s1, 'articles', 'id'))
    outputs.extend(util.get_data(s1, 'articles', 'title'))
    outputs.extend(util.get_data(s1, 'articles', 'text'))
    return util.add_warnings(outputs)

Student Registration

Back to top

def liststudentcourses (conn, inputs):
    util.clear_warnings()
    outputs = []
    s0 = util.do_sql(conn, "SELECT * FROM student WHERE id = :x0", {'x0': inputs[0]})
    if util.has_rows(s0):
        s2 = util.do_sql(conn, "SELECT * FROM student WHERE id=:x0 AND password=:x1", {'x0': util.get_one_data(s0, 'student', 'id'), 'x1': inputs[1]})
        if util.has_rows(s2):
            s6 = util.do_sql(conn, "SELECT * FROM course c JOIN registration r on r.course_id = c.id WHERE r.student_id = :x0", {'x0': util.get_one_data(s2, 'student', 'id')})
            outputs.extend(util.get_data(s6, 'course', 'id'))
            outputs.extend(util.get_data(s6, 'course', 'teacher_id'))
            outputs.extend(util.get_data(s6, 'registration', 'course_id'))
            if util.has_rows(s6):
                s6_all = s6
                for s6 in s6_all:
                    s12 = util.do_sql(conn, "Select firstname, lastname from teacher where id = :x0", {'x0': util.get_one_data(s6, 'course', 'teacher_id')})
                    s13 = util.do_sql(conn, "SELECT count(*) FROM registration WHERE course_id = :x0", {'x0': util.get_one_data(s6, 'registration', 'course_id')})
                s6 = s6_all
            else:
                pass
        else:
            pass
    else:
        pass
    return util.add_warnings(outputs)

Synthetic Commands (Section 4.2)

Back to top

Simple Sequence (SS)

Back to top

• Table t1 has two columns:
  • id integer primary key
  • val integer

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    s2 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[2]})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    s2 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[2]})
    s3 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[3]})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    s2 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[2]})
    s3 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[3]})
    s4 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[4]})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    s2 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[2]})
    s3 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[3]})
    s4 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[4]})
    s5 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[5]})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    s2 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[2]})
    s3 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[3]})
    s4 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[4]})
    s5 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[5]})
    s6 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[6]})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    s2 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[2]})
    s3 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[3]})
    s4 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[4]})
    s5 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[5]})
    s6 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[6]})
    s7 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[7]})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    s2 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[2]})
    s3 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[3]})
    s4 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[4]})
    s5 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[5]})
    s6 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[6]})
    s7 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[7]})
    s8 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[8]})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    s2 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[2]})
    s3 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[3]})
    s4 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[4]})
    s5 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[5]})
    s6 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[6]})
    s7 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[7]})
    s8 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[8]})
    s9 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[9]})

Nested Conditionals (NC)

Back to top

• Table t1 has two columns:
  • id integer primary key
  • val integer
• Table t2 has two columns:
  • id integer primary key
  • val integer
• Table t3 has two columns:
  • id integer primary key
  • val integer
• Table t4 has two columns:
  • id integer primary key
  • val integer
• Table t5 has two columns:
  • id integer primary key
  • val integer
• Table t6 has two columns:
  • id integer primary key
  • val integer
• Table t7 has two columns:
  • id integer primary key
  • val integer
• Table t8 has two columns:
  • id integer primary key
  • val integer
• Table t9 has two columns:
  • id integer primary key
  • val integer

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1", {})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1", {})
    if s1:
        s2 = util.do_sql(conn, "SELECT * FROM t2", {})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1", {})
    if s1:
        s2 = util.do_sql(conn, "SELECT * FROM t2", {})
        if s2:
            s3 = util.do_sql(conn, "SELECT * FROM t3", {})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1", {})
    if s1:
        s2 = util.do_sql(conn, "SELECT * FROM t2", {})
        if s2:
            s3 = util.do_sql(conn, "SELECT * FROM t3", {})
            if s3:
                s4 = util.do_sql(conn, "SELECT * FROM t4", {})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1", {})
    if s1:
        s2 = util.do_sql(conn, "SELECT * FROM t2", {})
        if s2:
            s3 = util.do_sql(conn, "SELECT * FROM t3", {})
            if s3:
                s4 = util.do_sql(conn, "SELECT * FROM t4", {})
                if s4:
                    s5 = util.do_sql(conn, "SELECT * FROM t5", {})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1", {})
    if s1:
        s2 = util.do_sql(conn, "SELECT * FROM t2", {})
        if s2:
            s3 = util.do_sql(conn, "SELECT * FROM t3", {})
            if s3:
                s4 = util.do_sql(conn, "SELECT * FROM t4", {})
                if s4:
                    s5 = util.do_sql(conn, "SELECT * FROM t5", {})
                    if s5:
                        s6 = util.do_sql(conn, "SELECT * FROM t6", {})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1", {})
    if s1:
        s2 = util.do_sql(conn, "SELECT * FROM t2", {})
        if s2:
            s3 = util.do_sql(conn, "SELECT * FROM t3", {})
            if s3:
                s4 = util.do_sql(conn, "SELECT * FROM t4", {})
                if s4:
                    s5 = util.do_sql(conn, "SELECT * FROM t5", {})
                    if s5:
                        s6 = util.do_sql(conn, "SELECT * FROM t6", {})
                        if s6:
                            s7 = util.do_sql(conn, "SELECT * FROM t7", {})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1", {})
    if s1:
        s2 = util.do_sql(conn, "SELECT * FROM t2", {})
        if s2:
            s3 = util.do_sql(conn, "SELECT * FROM t3", {})
            if s3:
                s4 = util.do_sql(conn, "SELECT * FROM t4", {})
                if s4:
                    s5 = util.do_sql(conn, "SELECT * FROM t5", {})
                    if s5:
                        s6 = util.do_sql(conn, "SELECT * FROM t6", {})
                        if s6:
                            s7 = util.do_sql(conn, "SELECT * FROM t7", {})
                            if s7:
                                s8 = util.do_sql(conn, "SELECT * FROM t8", {})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1", {})
    if s1:
        s2 = util.do_sql(conn, "SELECT * FROM t2", {})
        if s2:
            s3 = util.do_sql(conn, "SELECT * FROM t3", {})
            if s3:
                s4 = util.do_sql(conn, "SELECT * FROM t4", {})
                if s4:
                    s5 = util.do_sql(conn, "SELECT * FROM t5", {})
                    if s5:
                        s6 = util.do_sql(conn, "SELECT * FROM t6", {})
                        if s6:
                            s7 = util.do_sql(conn, "SELECT * FROM t7", {})
                            if s7:
                                s8 = util.do_sql(conn, "SELECT * FROM t8", {})
                                if s8:
                                    s9 = util.do_sql(conn, "SELECT * FROM t9", {})

Unambiguous Long Reference Chains (UL)

Back to top

• Table t1 has two columns:
  • id integer primary key
  • val integer
• Table t2 has two columns:
  • id integer primary key
  • val integer
• Table t3 has two columns:
  • id integer primary key
  • val integer
• Table t4 has two columns:
  • id integer primary key
  • val integer
• Table t5 has two columns:
  • id integer primary key
  • val integer
• Table t6 has two columns:
  • id integer primary key
  • val integer
• Table t7 has two columns:
  • id integer primary key
  • val integer
• Table t8 has two columns:
  • id integer primary key
  • val integer
• Table t9 has two columns:
  • id integer primary key
  • val integer

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    if s1:
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": util.get_one_data(s1, 't1', 'val')})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    if s1:
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": util.get_one_data(s1, 't1', 'val')})
        if s2:
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": util.get_one_data(s2, 't2', 'val')})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    if s1:
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": util.get_one_data(s1, 't1', 'val')})
        if s2:
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": util.get_one_data(s2, 't2', 'val')})
            if s3:
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": util.get_one_data(s3, 't3', 'val')})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    if s1:
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": util.get_one_data(s1, 't1', 'val')})
        if s2:
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": util.get_one_data(s2, 't2', 'val')})
            if s3:
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": util.get_one_data(s3, 't3', 'val')})
                if s4:
                    s5 = util.do_sql(conn, "SELECT * FROM t5 WHERE id = :x", {"x": util.get_one_data(s4, 't4', 'val')})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    if s1:
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": util.get_one_data(s1, 't1', 'val')})
        if s2:
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": util.get_one_data(s2, 't2', 'val')})
            if s3:
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": util.get_one_data(s3, 't3', 'val')})
                if s4:
                    s5 = util.do_sql(conn, "SELECT * FROM t5 WHERE id = :x", {"x": util.get_one_data(s4, 't4', 'val')})
                    if s5:
                        s6 = util.do_sql(conn, "SELECT * FROM t6 WHERE id = :x", {"x": util.get_one_data(s5, 't5', 'val')})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    if s1:
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": util.get_one_data(s1, 't1', 'val')})
        if s2:
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": util.get_one_data(s2, 't2', 'val')})
            if s3:
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": util.get_one_data(s3, 't3', 'val')})
                if s4:
                    s5 = util.do_sql(conn, "SELECT * FROM t5 WHERE id = :x", {"x": util.get_one_data(s4, 't4', 'val')})
                    if s5:
                        s6 = util.do_sql(conn, "SELECT * FROM t6 WHERE id = :x", {"x": util.get_one_data(s5, 't5', 'val')})
                        if s6:
                            s7 = util.do_sql(conn, "SELECT * FROM t7 WHERE id = :x", {"x": util.get_one_data(s6, 't6', 'val')})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    if s1:
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": util.get_one_data(s1, 't1', 'val')})
        if s2:
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": util.get_one_data(s2, 't2', 'val')})
            if s3:
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": util.get_one_data(s3, 't3', 'val')})
                if s4:
                    s5 = util.do_sql(conn, "SELECT * FROM t5 WHERE id = :x", {"x": util.get_one_data(s4, 't4', 'val')})
                    if s5:
                        s6 = util.do_sql(conn, "SELECT * FROM t6 WHERE id = :x", {"x": util.get_one_data(s5, 't5', 'val')})
                        if s6:
                            s7 = util.do_sql(conn, "SELECT * FROM t7 WHERE id = :x", {"x": util.get_one_data(s6, 't6', 'val')})
                            if s7:
                                s8 = util.do_sql(conn, "SELECT * FROM t8 WHERE id = :x", {"x": util.get_one_data(s7, 't7', 'val')})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    if s1:
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": util.get_one_data(s1, 't1', 'val')})
        if s2:
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": util.get_one_data(s2, 't2', 'val')})
            if s3:
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": util.get_one_data(s3, 't3', 'val')})
                if s4:
                    s5 = util.do_sql(conn, "SELECT * FROM t5 WHERE id = :x", {"x": util.get_one_data(s4, 't4', 'val')})
                    if s5:
                        s6 = util.do_sql(conn, "SELECT * FROM t6 WHERE id = :x", {"x": util.get_one_data(s5, 't5', 'val')})
                        if s6:
                            s7 = util.do_sql(conn, "SELECT * FROM t7 WHERE id = :x", {"x": util.get_one_data(s6, 't6', 'val')})
                            if s7:
                                s8 = util.do_sql(conn, "SELECT * FROM t8 WHERE id = :x", {"x": util.get_one_data(s7, 't7', 'val')})
                                if s8:
                                    s9 = util.do_sql(conn, "SELECT * FROM t9 WHERE id = :x", {"x": util.get_one_data(s8, 't8', 'val')})

Ambiguous Long Reference Chains (AL)

Back to top

• Table t1 has two columns:
  • id integer primary key
  • val integer
• Table t2 has two columns:
  • id integer primary key
  • val integer
• Table t3 has two columns:
  • id integer primary key
  • val integer
• Table t4 has two columns:
  • id integer primary key
  • val integer
• Table t5 has two columns:
  • id integer primary key
  • val integer
• Table t6 has two columns:
  • id integer primary key
  • val integer
• Table t7 has two columns:
  • id integer primary key
  • val integer
• Table t8 has two columns:
  • id integer primary key
  • val integer
• Table t9 has two columns:
  • id integer primary key
  • val integer

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    if s1:
        s2_ = util.do_sql(conn, "SELECT * FROM t2", {})
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": util.get_one_data(s1, 't1', 'val')})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    if s1:
        s2_ = util.do_sql(conn, "SELECT * FROM t2", {})
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": util.get_one_data(s1, 't1', 'val')})
        if s2:
            s3_ = util.do_sql(conn, "SELECT * FROM t3", {})
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": util.get_one_data(s2, 't2', 'val')})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    if s1:
        s2_ = util.do_sql(conn, "SELECT * FROM t2", {})
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": util.get_one_data(s1, 't1', 'val')})
        if s2:
            s3_ = util.do_sql(conn, "SELECT * FROM t3", {})
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": util.get_one_data(s2, 't2', 'val')})
            if s3:
                s4_ = util.do_sql(conn, "SELECT * FROM t4", {})
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": util.get_one_data(s3, 't3', 'val')})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    if s1:
        s2_ = util.do_sql(conn, "SELECT * FROM t2", {})
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": util.get_one_data(s1, 't1', 'val')})
        if s2:
            s3_ = util.do_sql(conn, "SELECT * FROM t3", {})
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": util.get_one_data(s2, 't2', 'val')})
            if s3:
                s4_ = util.do_sql(conn, "SELECT * FROM t4", {})
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": util.get_one_data(s3, 't3', 'val')})
                if s4:
                    s5_ = util.do_sql(conn, "SELECT * FROM t5", {})
                    s5 = util.do_sql(conn, "SELECT * FROM t5 WHERE id = :x", {"x": util.get_one_data(s4, 't4', 'val')})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    if s1:
        s2_ = util.do_sql(conn, "SELECT * FROM t2", {})
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": util.get_one_data(s1, 't1', 'val')})
        if s2:
            s3_ = util.do_sql(conn, "SELECT * FROM t3", {})
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": util.get_one_data(s2, 't2', 'val')})
            if s3:
                s4_ = util.do_sql(conn, "SELECT * FROM t4", {})
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": util.get_one_data(s3, 't3', 'val')})
                if s4:
                    s5_ = util.do_sql(conn, "SELECT * FROM t5", {})
                    s5 = util.do_sql(conn, "SELECT * FROM t5 WHERE id = :x", {"x": util.get_one_data(s4, 't4', 'val')})
                    if s5:
                        s6_ = util.do_sql(conn, "SELECT * FROM t6", {})
                        s6 = util.do_sql(conn, "SELECT * FROM t6 WHERE id = :x", {"x": util.get_one_data(s5, 't5', 'val')})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    if s1:
        s2_ = util.do_sql(conn, "SELECT * FROM t2", {})
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": util.get_one_data(s1, 't1', 'val')})
        if s2:
            s3_ = util.do_sql(conn, "SELECT * FROM t3", {})
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": util.get_one_data(s2, 't2', 'val')})
            if s3:
                s4_ = util.do_sql(conn, "SELECT * FROM t4", {})
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": util.get_one_data(s3, 't3', 'val')})
                if s4:
                    s5_ = util.do_sql(conn, "SELECT * FROM t5", {})
                    s5 = util.do_sql(conn, "SELECT * FROM t5 WHERE id = :x", {"x": util.get_one_data(s4, 't4', 'val')})
                    if s5:
                        s6_ = util.do_sql(conn, "SELECT * FROM t6", {})
                        s6 = util.do_sql(conn, "SELECT * FROM t6 WHERE id = :x", {"x": util.get_one_data(s5, 't5', 'val')})
                        if s6:
                            s7_ = util.do_sql(conn, "SELECT * FROM t7", {})
                            s7 = util.do_sql(conn, "SELECT * FROM t7 WHERE id = :x", {"x": util.get_one_data(s6, 't6', 'val')})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    if s1:
        s2_ = util.do_sql(conn, "SELECT * FROM t2", {})
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": util.get_one_data(s1, 't1', 'val')})
        if s2:
            s3_ = util.do_sql(conn, "SELECT * FROM t3", {})
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": util.get_one_data(s2, 't2', 'val')})
            if s3:
                s4_ = util.do_sql(conn, "SELECT * FROM t4", {})
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": util.get_one_data(s3, 't3', 'val')})
                if s4:
                    s5_ = util.do_sql(conn, "SELECT * FROM t5", {})
                    s5 = util.do_sql(conn, "SELECT * FROM t5 WHERE id = :x", {"x": util.get_one_data(s4, 't4', 'val')})
                    if s5:
                        s6_ = util.do_sql(conn, "SELECT * FROM t6", {})
                        s6 = util.do_sql(conn, "SELECT * FROM t6 WHERE id = :x", {"x": util.get_one_data(s5, 't5', 'val')})
                        if s6:
                            s7_ = util.do_sql(conn, "SELECT * FROM t7", {})
                            s7 = util.do_sql(conn, "SELECT * FROM t7 WHERE id = :x", {"x": util.get_one_data(s6, 't6', 'val')})
                            if s7:
                                s8_ = util.do_sql(conn, "SELECT * FROM t8", {})
                                s8 = util.do_sql(conn, "SELECT * FROM t8 WHERE id = :x", {"x": util.get_one_data(s7, 't7', 'val')})

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    if s1:
        s2_ = util.do_sql(conn, "SELECT * FROM t2", {})
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": util.get_one_data(s1, 't1', 'val')})
        if s2:
            s3_ = util.do_sql(conn, "SELECT * FROM t3", {})
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": util.get_one_data(s2, 't2', 'val')})
            if s3:
                s4_ = util.do_sql(conn, "SELECT * FROM t4", {})
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": util.get_one_data(s3, 't3', 'val')})
                if s4:
                    s5_ = util.do_sql(conn, "SELECT * FROM t5", {})
                    s5 = util.do_sql(conn, "SELECT * FROM t5 WHERE id = :x", {"x": util.get_one_data(s4, 't4', 'val')})
                    if s5:
                        s6_ = util.do_sql(conn, "SELECT * FROM t6", {})
                        s6 = util.do_sql(conn, "SELECT * FROM t6 WHERE id = :x", {"x": util.get_one_data(s5, 't5', 'val')})
                        if s6:
                            s7_ = util.do_sql(conn, "SELECT * FROM t7", {})
                            s7 = util.do_sql(conn, "SELECT * FROM t7 WHERE id = :x", {"x": util.get_one_data(s6, 't6', 'val')})
                            if s7:
                                s8_ = util.do_sql(conn, "SELECT * FROM t8", {})
                                s8 = util.do_sql(conn, "SELECT * FROM t8 WHERE id = :x", {"x": util.get_one_data(s7, 't7', 'val')})
                                if s8:
                                    s9_ = util.do_sql(conn, "SELECT * FROM t9", {})
                                    s9 = util.do_sql(conn, "SELECT * FROM t9 WHERE id = :x", {"x": util.get_one_data(s8, 't8', 'val')})

Ambiguous Short Reference Chains (AS)

Back to top

• Table t1 has two columns:
  • id integer primary key
  • val integer
• Table t2 has two columns:
  • id integer primary key
  • val integer
• Table t3 has two columns:
  • id integer primary key
  • val integer
• Table t4 has two columns:
  • id integer primary key
  • val integer
• Table t5 has two columns:
  • id integer primary key
  • val integer
• Table t6 has two columns:
  • id integer primary key
  • val integer
• Table t7 has two columns:
  • id integer primary key
  • val integer
• Table t8 has two columns:
  • id integer primary key
  • val integer
• Table t9 has two columns:
  • id integer primary key
  • val integer

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    print(util.get_data(s1, 't1', 'val'))

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    print(util.get_data(s1, 't1', 'val'))
    if s1:
        s2_ = util.do_sql(conn, "SELECT * FROM t2", {})
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": sys.argv[2]})
        print(util.get_data(s2, 't2', 'val'))

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    print(util.get_data(s1, 't1', 'val'))
    if s1:
        s2_ = util.do_sql(conn, "SELECT * FROM t2", {})
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": sys.argv[2]})
        print(util.get_data(s2, 't2', 'val'))
        if s2:
            s3_ = util.do_sql(conn, "SELECT * FROM t3", {})
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": sys.argv[3]})
            print(util.get_data(s3, 't3', 'val'))

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    print(util.get_data(s1, 't1', 'val'))
    if s1:
        s2_ = util.do_sql(conn, "SELECT * FROM t2", {})
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": sys.argv[2]})
        print(util.get_data(s2, 't2', 'val'))
        if s2:
            s3_ = util.do_sql(conn, "SELECT * FROM t3", {})
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": sys.argv[3]})
            print(util.get_data(s3, 't3', 'val'))
            if s3:
                s4_ = util.do_sql(conn, "SELECT * FROM t4", {})
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": sys.argv[4]})
                print(util.get_data(s4, 't4', 'val'))

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    print(util.get_data(s1, 't1', 'val'))
    if s1:
        s2_ = util.do_sql(conn, "SELECT * FROM t2", {})
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": sys.argv[2]})
        print(util.get_data(s2, 't2', 'val'))
        if s2:
            s3_ = util.do_sql(conn, "SELECT * FROM t3", {})
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": sys.argv[3]})
            print(util.get_data(s3, 't3', 'val'))
            if s3:
                s4_ = util.do_sql(conn, "SELECT * FROM t4", {})
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": sys.argv[4]})
                print(util.get_data(s4, 't4', 'val'))
                if s4:
                    s5_ = util.do_sql(conn, "SELECT * FROM t5", {})
                    s5 = util.do_sql(conn, "SELECT * FROM t5 WHERE id = :x", {"x": sys.argv[5]})
                    print(util.get_data(s5, 't5', 'val'))

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    print(util.get_data(s1, 't1', 'val'))
    if s1:
        s2_ = util.do_sql(conn, "SELECT * FROM t2", {})
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": sys.argv[2]})
        print(util.get_data(s2, 't2', 'val'))
        if s2:
            s3_ = util.do_sql(conn, "SELECT * FROM t3", {})
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": sys.argv[3]})
            print(util.get_data(s3, 't3', 'val'))
            if s3:
                s4_ = util.do_sql(conn, "SELECT * FROM t4", {})
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": sys.argv[4]})
                print(util.get_data(s4, 't4', 'val'))
                if s4:
                    s5_ = util.do_sql(conn, "SELECT * FROM t5", {})
                    s5 = util.do_sql(conn, "SELECT * FROM t5 WHERE id = :x", {"x": sys.argv[5]})
                    print(util.get_data(s5, 't5', 'val'))
                    if s5:
                        s6_ = util.do_sql(conn, "SELECT * FROM t6", {})
                        s6 = util.do_sql(conn, "SELECT * FROM t6 WHERE id = :x", {"x": sys.argv[6]})
                        print(util.get_data(s6, 't6', 'val'))

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    print(util.get_data(s1, 't1', 'val'))
    if s1:
        s2_ = util.do_sql(conn, "SELECT * FROM t2", {})
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": sys.argv[2]})
        print(util.get_data(s2, 't2', 'val'))
        if s2:
            s3_ = util.do_sql(conn, "SELECT * FROM t3", {})
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": sys.argv[3]})
            print(util.get_data(s3, 't3', 'val'))
            if s3:
                s4_ = util.do_sql(conn, "SELECT * FROM t4", {})
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": sys.argv[4]})
                print(util.get_data(s4, 't4', 'val'))
                if s4:
                    s5_ = util.do_sql(conn, "SELECT * FROM t5", {})
                    s5 = util.do_sql(conn, "SELECT * FROM t5 WHERE id = :x", {"x": sys.argv[5]})
                    print(util.get_data(s5, 't5', 'val'))
                    if s5:
                        s6_ = util.do_sql(conn, "SELECT * FROM t6", {})
                        s6 = util.do_sql(conn, "SELECT * FROM t6 WHERE id = :x", {"x": sys.argv[6]})
                        print(util.get_data(s6, 't6', 'val'))
                        if s6:
                            s7_ = util.do_sql(conn, "SELECT * FROM t7", {})
                            s7 = util.do_sql(conn, "SELECT * FROM t7 WHERE id = :x", {"x": sys.argv[7]})
                            print(util.get_data(s7, 't7', 'val'))

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    print(util.get_data(s1, 't1', 'val'))
    if s1:
        s2_ = util.do_sql(conn, "SELECT * FROM t2", {})
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": sys.argv[2]})
        print(util.get_data(s2, 't2', 'val'))
        if s2:
            s3_ = util.do_sql(conn, "SELECT * FROM t3", {})
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": sys.argv[3]})
            print(util.get_data(s3, 't3', 'val'))
            if s3:
                s4_ = util.do_sql(conn, "SELECT * FROM t4", {})
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": sys.argv[4]})
                print(util.get_data(s4, 't4', 'val'))
                if s4:
                    s5_ = util.do_sql(conn, "SELECT * FROM t5", {})
                    s5 = util.do_sql(conn, "SELECT * FROM t5 WHERE id = :x", {"x": sys.argv[5]})
                    print(util.get_data(s5, 't5', 'val'))
                    if s5:
                        s6_ = util.do_sql(conn, "SELECT * FROM t6", {})
                        s6 = util.do_sql(conn, "SELECT * FROM t6 WHERE id = :x", {"x": sys.argv[6]})
                        print(util.get_data(s6, 't6', 'val'))
                        if s6:
                            s7_ = util.do_sql(conn, "SELECT * FROM t7", {})
                            s7 = util.do_sql(conn, "SELECT * FROM t7 WHERE id = :x", {"x": sys.argv[7]})
                            print(util.get_data(s7, 't7', 'val'))
                            if s7:
                                s8_ = util.do_sql(conn, "SELECT * FROM t8", {})
                                s8 = util.do_sql(conn, "SELECT * FROM t8 WHERE id = :x", {"x": sys.argv[8]})
                                print(util.get_data(s8, 't8', 'val'))

import sys
import active_utils as util

with util.open_database('active_test_app') as conn:
    s1_ = util.do_sql(conn, "SELECT * FROM t1", {})
    s1 = util.do_sql(conn, "SELECT * FROM t1 WHERE id = :x", {"x": sys.argv[1]})
    print(util.get_data(s1, 't1', 'val'))
    if s1:
        s2_ = util.do_sql(conn, "SELECT * FROM t2", {})
        s2 = util.do_sql(conn, "SELECT * FROM t2 WHERE id = :x", {"x": sys.argv[2]})
        print(util.get_data(s2, 't2', 'val'))
        if s2:
            s3_ = util.do_sql(conn, "SELECT * FROM t3", {})
            s3 = util.do_sql(conn, "SELECT * FROM t3 WHERE id = :x", {"x": sys.argv[3]})
            print(util.get_data(s3, 't3', 'val'))
            if s3:
                s4_ = util.do_sql(conn, "SELECT * FROM t4", {})
                s4 = util.do_sql(conn, "SELECT * FROM t4 WHERE id = :x", {"x": sys.argv[4]})
                print(util.get_data(s4, 't4', 'val'))
                if s4:
                    s5_ = util.do_sql(conn, "SELECT * FROM t5", {})
                    s5 = util.do_sql(conn, "SELECT * FROM t5 WHERE id = :x", {"x": sys.argv[5]})
                    print(util.get_data(s5, 't5', 'val'))
                    if s5:
                        s6_ = util.do_sql(conn, "SELECT * FROM t6", {})
                        s6 = util.do_sql(conn, "SELECT * FROM t6 WHERE id = :x", {"x": sys.argv[6]})
                        print(util.get_data(s6, 't6', 'val'))
                        if s6:
                            s7_ = util.do_sql(conn, "SELECT * FROM t7", {})
                            s7 = util.do_sql(conn, "SELECT * FROM t7 WHERE id = :x", {"x": sys.argv[7]})
                            print(util.get_data(s7, 't7', 'val'))
                            if s7:
                                s8_ = util.do_sql(conn, "SELECT * FROM t8", {})
                                s8 = util.do_sql(conn, "SELECT * FROM t8 WHERE id = :x", {"x": sys.argv[8]})
                                print(util.get_data(s8, 't8', 'val'))
                                if s8:
                                    s9_ = util.do_sql(conn, "SELECT * FROM t9", {})
                                    s9 = util.do_sql(conn, "SELECT * FROM t9 WHERE id = :x", {"x": sys.argv[9]})
                                    print(util.get_data(s9, 't9', 'val'))