Flask, managing DB connections(without ORM) - flask

Question

I'm newbie in Flask and web programming on the whole, so I'm trying to understand the principles of contexts and db operations of the framework.
Now I want to make out how to manage DB connections without Sql-Alchemy and other ORMs, just with plain sql.
So the simple example with sqlite3 db.
The structure of my test project:
.
├── application
│   ├── __init__.py
│   ├── routes.py
│   └── templates
│   ├── base.html
│   ├── index.html
├── config.py
├── requirements.txt
├── run.py
└── test.db
init.py
from flask import Flask,g
from config import Config
import sqlite3
app = Flask(__name__)
app.config.from_object(Config)
def get_db():
db = getattr(g, '_database', None)
if db is None:
db = g._database = sqlite3.connect('test.db')
return db
#app.teardown_appcontext
def close_connection(exception):
db = getattr(g, '_database', None)
if db is not None:
db.close()
from application import routes
routes.py
# -*- coding: utf-8 -*-
from flask import render_template,redirect
from application import app, get_db
# import sqlite3
#app.route('/')
def index():
cur = get_db().cursor()
cur.execute('select*from users')
select=cur.fetchall()
return render_template('index.html',title='DBSelectTest', posts=select)
I've copied "get_db" and "close_connection" functions from the official site of Flask framework, but I'm not clearly understand how it works and what will be the difference if I use just simple code for "def get_db" without "g" like this:
con = sqlite3.connect("catalog.db")
cur = con.cursor()
And obviously close connections after query is done like this:
cur.close()
con.close()
I'm just trying to catch how the application and the request contexts work in that case with using g.
The main problem that I don't understand what is a "request" in that case.
My wrong understanding of this case:
So in init.py we create "global variable" g which is in application context and should be accessible for each tread in request context.
In routes.py we get query from client with root route("/") so in that moment request context is created and after that application context as well.
So as I understand "get_db" is accessible from our request context and we're able to connect to the db and use that g value in all functions inside the current tread? What about "close_connection"? Because of decorator "teardown_appcontext" the connections have to been closed after app context is failed or ended? Will it work in my code?
So, could anyone provide a correct case of using plain sql with separate connection function?

Answer 1

Flask application and request contexts behave like global variables for the purposes of your code, but are in fact proxies that will contain different values every time your application receives a new web request. The request context contains data specific to that particular web request such as form data, remote ip address, http headers, etc.
Every time a web request is received, new application and request contexts are created before your view function is called and these are then destroyed after a response has been returned and the processing of the web request has been completed. The g proxy is stored with the application context and it's used to store variables with a lifetime of that particular web request. This is used to pass information between functions called by flask as a result of events and signals.
In your code you use a decorator to register the function close_connection with the teardown_appcontext event, thus guaranteeing it is called after completion of handling of every web request. There are many other events that can be hooked to execute before or after your view function to provide pre- and post-processing of the request or response. The g proxy is merely used to store your database connection, which was created in your view function, and makes it available to the close_connection function where it is guaranteed to be closed. This prevents the database connection being left open if an error occurs in your application code.
The pattern, as shown below, is used to accomplish exactly the same thing as would be achieved by using a context manager (or try, except, finally block) to close the database connection within your function. This pattern is commonly used with an ORM to hide the underlying management of the database connection and reduce boilerplate code. The following code should produce the same effect without the use of events or the g proxy.
# -*- coding: utf-8 -*-
from flask import render_template, redirect
from application import app
from contextlib import closing
import sqlite3
def get_db():
return sqlite3.connect('test.db')
#app.route('/')
def index():
with closing(get_db()) as conn:
cur = conn.cursor()
cur.execute('select * from users')
select = cur.fetchall()
return render_template('index.html', title='DBSelectTest', posts=select)