def check_map(uri, url_root): """ return a tuple of the rule and kw. """ # TODO: Building the Map each time this is called seems like it could be more effiecent. c = db.cursor() try: c.execute(fetch_query_string('select_route_where_dynamic.sql')) except sqlite3.OperationalError as err: current_app.logger.error("OperationalError: %s", err) return (None, None) result = c.fetchall() if result: (routes, col_names) = rowify(result, c.description) #current_app.logger.debug( [x['rule'] for x in routes] ) rules = map( lambda r: Rule(r['rule'], endpoint='dynamic'), routes ) d_map = Map( rules ) map_adapter = d_map.bind(url_root) #current_app.logger.debug(uri) try: (rule, rule_kw) = map_adapter.match(path_info=uri, return_rule=True) #current_app.logger.debug(rule) return (str(rule), rule_kw) except HTTPException: pass return (None, {})
def _query(_node_id, value=None, **kw): "Look up value by using Query table" query_result = [] try: query_result = db.execute(text(fetch_query_string('select_query_from_node.sql')), **kw).fetchall() except DatabaseError as err: current_app.logger.error("DatabaseError: %s, %s", err, kw) return value #current_app.logger.debug("queries kw: %s", kw) #current_app.logger.debug("queries value: %s", value) current_app.logger.debug("queries: %s", query_result) if query_result: values = [] for query_name in [x['name'] for x in query_result]: if query_name: result = [] try: current_app.logger.debug("query_name: %s", query_name) #current_app.logger.debug("kw: %s", kw) # Query string can be insert or select here #statement = text(fetch_query_string(query_name)) #params = [x.key for x in statement.params().get_children()] #skw = {key: kw[key] for key in params} #result = db.execute(statement, **skw) result = db.execute(text(fetch_query_string(query_name)), **kw) current_app.logger.debug("result query: %s", result.keys()) except (DatabaseError, StatementError) as err: current_app.logger.error("DatabaseError (%s) %s: %s", query_name, kw, err) if result and result.returns_rows: result = result.fetchall() #values.append(([[dict(zip(result.keys(), x)) for x in result]], result.keys())) #values.append((result.fetchall(), result.keys())) #current_app.logger.debug("fetchall: %s", values) if len(result) == 0: values.append(([], [])) else: current_app.logger.debug("result: %s", result) # There may be more results, but only interested in the # first one. Use the older rowify method for now. # TODO: use case for rowify? values.append(rowify(result, [(x, None) for x in result[0].keys()])) #current_app.logger.debug("fetchone: %s", values) value = values #current_app.logger.debug("value: %s", value) return value
def node_from_uri(uri, method="GET"): # check if page exists in data_path # a//b == a/b/ == a/./b == a/foo/../b # '' == '.' # Prepend the uri with '/' and normalize uri = os.path.normpath(os.path.join('/', uri)) uri, ext = os.path.splitext(uri) if not uri.endswith('/'): uri = ''.join((uri, '/')) #current_app.logger.debug('uri: "%s"' % uri) rule_kw = {} select_node_from_route = fetch_query_string('select_node_from_route.sql') c = db.cursor() try: c.execute(select_node_from_route, {'uri':uri, 'method':method}) except sqlite3.DatabaseError as err: current_app.logger.error("DatabaseError: %s", err) result = c.fetchall() #current_app.logger.debug('result: "%s"' % result) if not result or len(result) == 0: # See if the uri matches any dynamic rules (rule, rule_kw) = check_map(uri, request.url_root) #current_app.logger.debug(rule) #current_app.logger.debug('rule: "%s"' % rule or '') if rule: try: c.execute(select_node_from_route, {'uri':rule, 'method':method}) result = c.fetchall() except sqlite3.DatabaseError as err: current_app.logger.error("DatabaseError: %s", err) if result: (result, col_names) = rowify(result, c.description) # Only one result for a getting a node from a unique path. return (result[0], rule_kw) return (None, rule_kw)