def query(self, session, info): """Save the query results in filesystem and db Parameters ---------- session : dict AskOmics session graph_state : dict JSON graph state Returns ------- dict error: True if error, else False errorMessage: the error message of error, else an empty string """ try: info["celery_id"] = self.request.id result = Result(app, session, info, force_no_db=True) # Save job in database database result.set_celery_id(self.request.id) result.update_db_status("started", update_celery=True, update_date=True) # launch query query = SparqlQuery(app, session, info["graph_state"]) query.build_query_from_json(for_editor=False) headers = query.selects results = [] if query.graphs: query_launcher = SparqlQueryLauncher(app, session, get_result_query=True, federated=query.federated, endpoints=query.endpoints) headers, results = query_launcher.process_query(query.sparql, isql_api=True) # write result to a file file_size = result.save_result_in_file(headers, results) # Update database status result.update_db_status("success", size=file_size) except Exception as e: traceback.print_exc(file=sys.stdout) trace = traceback.format_exc() result.update_db_status("error", error=True, error_message=str(e), traceback=trace) result.rollback() raise e return {'error': True, 'errorMessage': str(e)} return {'error': False, 'errorMessage': ''}
def get_sparql_query(): """Get sparql query of result for the query editor Returns ------- json query: the sparql query error: True if error, else False errorMessage: the error message of error, else an empty string """ try: files_utils = FilesUtils(current_app, session) disk_space = files_utils.get_size_occupied_by_user( ) if "user" in session else None file_id = request.get_json()["fileId"] result_info = {"id": file_id} result = Result(current_app, session, result_info) query = SparqlQuery(current_app, session) sparql = result.get_sparql_query() # get graphs and endpoints used in the query graphs = result.graphs endpoints = result.endpoints # Get all graphs and endpoint, and mark as selected the used one graphs, endpoints = query.get_graphs_and_endpoints( selected_graphs=graphs, selected_endpoints=endpoints) # Build sparql query from json if needed if sparql is None: query.json = result.get_graph_state() query.build_query_from_json(for_editor=True) sparql = query.sparql except Exception as e: traceback.print_exc(file=sys.stdout) return jsonify({ 'query': {}, 'graphs': [], 'endpoints': [], 'diskSpace': 0, 'error': True, 'errorMessage': str(e) }), 500 return jsonify({ 'query': sparql, 'graphs': graphs, 'endpoints': endpoints, 'diskSpace': disk_space, 'error': False, 'errorMessage': '' })
def save_result(): """Save a query in filesystem and db, using a celery task Returns ------- json task_id: celery task id error: True if error, else False errorMessage: the error message of error, else an empty string """ try: files_utils = FilesUtils(current_app, session) disk_space = files_utils.get_size_occupied_by_user() if "user" in session else None if session["user"]["quota"] > 0 and disk_space >= session["user"]["quota"]: return jsonify({ 'error': True, 'errorMessage': "Exceeded quota", 'task_id': None }), 500 # Get query and endpoints and graphs of the query query = SparqlQuery(current_app, session, request.get_json()["graphState"]) query.build_query_from_json(preview=False, for_editor=False) info = { "graph_state": query.json, "query": query.sparql, "graphs": query.graphs, "endpoints": query.endpoints, "celery_id": None } result = Result(current_app, session, info) info["id"] = result.save_in_db() session_dict = {"user": session["user"]} task = current_app.celery.send_task("query", (session_dict, info)) result.update_celery(task.id) except Exception as e: traceback.print_exc(file=sys.stdout) return jsonify({ 'error': True, 'errorMessage': str(e), 'task_id': None }), 500 return jsonify({ 'error': False, 'errorMessage': '', 'task_id': task.id })
def create_result(self, has_form=False): """Create a result entry in db Returns ------- dict Result info """ # Query: transcript concerned by DE and included in QTL if has_form: with open("tests/data/graphState_simple_query_form.json", "r") as file: file_content = file.read() else: with open("tests/data/graphState_simple_query.json", "r") as file: file_content = file.read() json_query = json.loads(file_content) # Get query and endpoints and graphs of the query query = SparqlQuery(self.app, self.session, json_query) query_launcher = SparqlQueryLauncher(self.app, self.session) query.build_query_from_json(preview=False, for_editor=False) info = { "graph_state": json_query, "query": query.sparql, "celery_id": '00000000-0000-0000-0000-000000000000', "graphs": query.graphs, "endpoints": query.endpoints } # Save job in database database result = Result(self.app, self.session, info) result.save_in_db() # Execute query and write result to file headers, results = query_launcher.process_query(query.sparql) file_size = result.save_result_in_file(headers, results) # Update database status result.update_db_status("success", size=file_size) return { "id": result.id, "path": result.file_path, "start": result.start, "end": result.end, "size": file_size }
def get_preview(): """Get a preview of query Returns ------- json resultsPreview: Preview of the query results headerPreview: Header of the results table error: True if error, else False errorMessage: the error message of error, else an empty string """ try: # If public datasets and queries are protected, dont return anything to unlogged users if "user" not in session and current_app.iniconfig.getboolean("askomics", "protect_public"): preview = [] header = [] else: data = request.get_json() if not (data and data.get("graphState")): return jsonify({ 'resultsPreview': [], 'headerPreview': [], 'error': True, 'errorMessage': "Missing graphState parameter" }), 400 query = SparqlQuery(current_app, session, data["graphState"], get_graphs=False) query.build_query_from_json(preview=True, for_editor=False) endpoints = query.endpoints federated = query.federated header = query.selects preview = [] if query.graphs: query_launcher = SparqlQueryLauncher(current_app, session, get_result_query=True, federated=federated, endpoints=endpoints) header, preview = query_launcher.process_query(query.sparql) except Exception as e: traceback.print_exc(file=sys.stdout) return jsonify({ 'resultsPreview': [], 'headerPreview': [], 'error': True, 'errorMessage': str(e) }), 500 return jsonify({ 'resultsPreview': preview, 'headerPreview': header, 'error': False, 'errorMessage': '' })