How to Migrate Your Flask App From SQL To MongoDB

1
pip install Flask-PyMongo Flask

1
from datetime import datetime
2
from bson.objectid import ObjectId
3
class Post:
4
    def __init__(self, title, content, date_posted=None, _id=None):
5
        self.title = title
6
        self.content = content
7
        self.date_posted = date_posted if date_posted else datetime.utcnow()
8
        self._id = _id if _id else ObjectId()
9
10
    def to_dict(self):
11
        return {
12
            "title": self.title,
13
            "content": self.content,
14
            "date_posted": self.date_posted,
15
            "_id": self._id
16
        }
17
18
    @staticmethod
19
    def from_dict(data):
20
        return Post(
21
            title=data.get('title'),
22
            content=data.get('content'),
23
            date_posted=data.get('date_posted'),
24
            _id=data.get('_id')
25
        )
26
27
    def __repr__(self):
28
        return f"Post('{self.title}', '{self.date_posted}')"

1
from flask import Flask
2
from flask_pymongo import PyMongo
3
from config import Config
4
5
6
app = Flask(__name__)
7
app.config.from_object(Config)
8
mongo = PyMongo(app)
9
10
11
from app import routes

1
import os
2
class Config:
3
    SECRET_KEY = os.urandom(24)
4
    MONGO_URI = 'mongodb://localhost:27017/blogdb'

1
from flask import render_template, url_for, flash, redirect, request
2
from app import app, mongo
3
from bson.objectid import ObjectId
4
from app.models import Post
5
from app.forms import PostForm
6
7
@app.route("/")
8
@app.route("/home")
9
def home():
10
    """
11
    Render the home page with a list of all posts.
12
    """
13
    posts_data = mongo.db.posts.find()
14
    posts = [Post.from_dict(post) for post in posts_data]
15
    return render_template("index.html", posts=posts)
16
17
18
@app.route("/post/new", methods=["GET", "POST"])
19
def new_post():
20
    """
21
    Handle the creation of a new post. Render the new post form and process the form submission.
22
23
    """
24
    form = PostForm()
25
    if form.validate_on_submit():
26
        post = Post(title=form.title.data, content=form.content.data)
27
        mongo.db.posts.insert_one(post.to_dict())
28
        flash("Your post has been created!", "success")
29
        return redirect(url_for("home"))
30
    return render_template("post.html", title="New Post", form=form)
31
32
33
@app.route("/post/<post_id>")
34
def post(post_id):
35
    """
36
    Display a single post by its ID.
37
    """
38
    post_data = mongo.db.posts.find_one_or_404({"_id": ObjectId(post_id)})
39
    post = Post.from_dict(post_data)
40
    return render_template("detail.html", post=post)
41
42
43
@app.route("/post/<post_id>/edit", methods=["GET", "POST"])
44
def edit_post(post_id):
45
    """
46
    Handle the editing of an existing post. Render the edit post form and process the form submission.
47
    """
48
    post_data = mongo.db.posts.find_one_or_404({"_id": ObjectId(post_id)})
49
    post = Post.from_dict(post_data)
50
    form = PostForm()
51
    if form.validate_on_submit():
52
        updated_post = {
53
            "$set": {"title": form.title.data, "content": form.content.data}
54
        }
55
        mongo.db.posts.update_one({"_id": ObjectId(post_id)}, updated_post)
56
        flash("Your post has been updated!", "success")
57
        return redirect(url_for("post", post_id=post_id))
58
    elif request.method == "GET":
59
        form.title.data = post.title
60
        form.content.data = post.content
61
    return render_template("edit_post.html", title="Edit Post", form=form)
62
63
64
@app.route("/post/<post_id>/delete", methods=["POST"])
65
def delete_post(post_id):
66
    """
67
    Handle the deletion of a post by its ID.
68
    """
69
    mongo.db.posts.delete_one({"_id": ObjectId(post_id)})
70
    flash("Your post has been deleted!", "success")
71
    return redirect(url_for("home"))
72
73
74
@app.route("/search", methods=["GET", "POST"])
75
def search():
76
    """
77
    Handle the search functionality for posts. Search for posts by title or content.
78
    """
79
    query = request.args.get("query")
80
    posts_data = mongo.db.posts.find(
81
        {
82
            "$or": [
83
                {"title": {"$regex": query, "$options": "i"}},
84
                {"content": {"$regex": query, "$options": "i"}},
85
            ]
86
        }
87
    )
88
    posts = [Post.from_dict(post) for post in posts_data]
89
    return render_template("index.html", posts=posts)

1
import sqlite3
2
3
4
# Connect to the SQLite database
5
db_path = 'relative/path/to/site.db'
6
conn = sqlite3.connect(db_path)
7
cursor = conn.cursor()
8
9
# Query to get all table names
10
cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
11
tables = cursor.fetchall()
12
13
# Close the connection
14
conn.close()
15
16
print(tables)

1
import sqlite3
2
import json
3
4
# Connect to the SQLite database
5
db_path = 'relative/path/to/site.db'
6
conn = sqlite3.connect(db_path)
7
cursor = conn.cursor()
8
9
# Export data from the 'post' table
10
cursor.execute("SELECT * FROM post")
11
rows = cursor.fetchall()
12
13
# Get the column names
14
column_names = [description[0] for description in cursor.description]
15
16
# Convert to list of dictionaries
17
data = [dict(zip(column_names, row)) for row in rows]
18
19
# Save to a JSON file
20
with open('post.json', 'w') as f:
21
    json.dump(data, f, indent=4)
22
23
# Close the connection
24
conn.close()

1
[
2
    {
3
        "id": 1,
4
        "title": " Superworm (Zophobas morio)",
5
        "content": "Superworms, scientifically known as Zophobas morio, are the larval stage of a darkling beetle species...",
6
        "date_posted": "2024-05-14 18:03:43.219562"
7
    },
8
    {
9
        "id": 2,
10
        "title": "MongoDB article",
11
        "content": "MongoDB is a widely-used NoSQL database known for its flexibility...",
12
        "date_posted": "2024-05-14 18:04:57.884181"
13
    },
14
    {
15
        "id": 3,
16
        "title": "Unique Techniques in Farming",
17
        "content": "Modern farming has evolved in various ways…",
18
        "date_posted": "2024-05-14 18:07:12.665001"
19
    },
20
    {
21
        "id": 4,
22
        "title": " Examples of NoSQL Databases",
23
        "content": "NoSQL databases have improved the way...",
24
        "date_posted": "2024-05-14 18:08:28.759601"
25
    },
26
    {
27
        "id": 5,
28
        "title": "d",
29
        "content": "d",
30
        "date_posted": "2024-05-18 18:06:59.767954"
31
    }
32
]

1
from pymongo import MongoClient
2
import json
3
from datetime import datetime
4
5
def import_json_to_mongo(db_name, collection_name, json_path):
6
    client = MongoClient("mongodb://localhost:27017/")
7
    db = client[db_name]
8
9
    def convert_date(data):
10
        # Update 'date_posted' field to datetime object
11
        for item in data:
12
            if 'date_posted' in item:
13
                item['date_posted'] = datetime.strptime(item['date_posted'], '%Y-%m-%d %H:%M:%S.%f')
14
        return data
15
16
    with open(json_path, 'r') as f:
17
        data = json.load(f)
18
        data = convert_date(data)
19
        db[collection_name].insert_many(data)
20
21
    client.close()
22
23
if __name__ == "__main__":
24
    db_name = 'blogdb'
25
    collection_name = 'posts'
26
    json_path = 'flask-mongo/post.json'
27
    import_json_to_mongo(db_name, collection_name, json_path)

1
python run.py