BogoToBogo
  • Home
  • About
  • Big Data
  • Machine Learning
  • AngularJS
  • Python
  • C++
  • go
  • DevOps
  • Kubernetes
  • Algorithms
  • More...
    • Qt 5
    • Linux
    • FFmpeg
    • Matlab
    • Django 1.8
    • Ruby On Rails
    • HTML5 & CSS

Flask blog app tutorial : Appendix (Tables & MySQL stored procedures / functions)

Python-Flask.png




Bookmark and Share





bogotobogo.com site search:



SQL Tables

Here are the tables used in Flask blog app:

mysql> show tables;
+------------------------+
| Tables_in_FlaskBlogApp |
+------------------------+
| blog_user              |
| tbl_blog               |
| tbl_likes              |
+------------------------+
3 rows in set (0.00 sec)


SQL scripts for the tables look like the following.

  1. blog:

    CREATE TABLE `FlaskBlogApp`.`blog_user` (
      `user_id` BIGINT NOT NULL AUTO_INCREMENT,
      `user_name` VARCHAR(45) NULL,
      `user_username` VARCHAR(45) NULL,
      `user_password` VARCHAR(85) NULL,
      PRIMARY KEY (`user_id`));
    
    mysql> desc blog_user;
    +---------------+-------------+------+-----+---------+----------------+
    | Field         | Type        | Null | Key | Default | Extra          |
    +---------------+-------------+------+-----+---------+----------------+
    | user_id       | bigint(20)  | NO   | PRI | NULL    | auto_increment |
    | user_name     | varchar(45) | YES  |     | NULL    |                |
    | user_username | varchar(45) | YES  |     | NULL    |                |
    | user_password | varchar(85) | YES  |     | NULL    |                |
    +---------------+-------------+------+-----+---------+----------------+
    4 rows in set (0.00 sec)
    

  2. tbl_blog:

    CREATE TABLE `tbl_blog` (
      `blog_id` int(11) NOT NULL AUTO_INCREMENT,
      `blog_title` varchar(45) DEFAULT NULL,
      `blog_description` varchar(5000) DEFAULT NULL,
      `blog_user_id` int(11) DEFAULT NULL,
      `blog_date` datetime DEFAULT NULL,
      PRIMARY KEY (`blog_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=latin1;
    
    ALTER TABLE `FlaskBlogApp`.`tbl_blog` 
    ADD COLUMN `blog_file_path` VARCHAR(200) NULL AFTER `blog_date`,
    ADD COLUMN `blog_accomplished` INT NULL DEFAULT 0 AFTER `blog_file_path`,
    ADD COLUMN `blog_private` INT NULL DEFAULT 0 AFTER `blog_accomplished`;
    
    mysql> desc tbl_blog;
    +-------------------+---------------+------+-----+---------+----------------+
    | Field             | Type          | Null | Key | Default | Extra          |
    +-------------------+---------------+------+-----+---------+----------------+
    | blog_id           | int(11)       | NO   | PRI | NULL    | auto_increment |
    | blog_title        | varchar(45)   | YES  |     | NULL    |                |
    | blog_description  | varchar(5000) | YES  |     | NULL    |                |
    | blog_user_id      | int(11)       | YES  |     | NULL    |                |
    | blog_date         | datetime      | YES  |     | NULL    |                |
    | blog_file_path    | varchar(200)  | YES  |     | NULL    |                |
    | blog_accomplished | int(11)       | YES  |     | 0       |                |
    | blog_private      | int(11)       | YES  |     | 0       |                |
    +-------------------+---------------+------+-----+---------+----------------+
    8 rows in set (0.01 sec)
    

  3. tbl_likes:

    CREATE TABLE `FlaskBlogApp`.`tbl_likes` (
      `blog_id` INT NOT NULL,
      `like_id` INT NOT NULL AUTO_INCREMENT,
      `user_id` INT NULL,
      `blog_like` INT NULL DEFAULT 0,
      PRIMARY KEY (`like_id`));
    
    mysql> desc tbl_likes;
    +-----------+---------+------+-----+---------+----------------+
    | Field     | Type    | Null | Key | Default | Extra          |
    +-----------+---------+------+-----+---------+----------------+
    | blog_id   | int(11) | NO   |     | NULL    |                |
    | like_id   | int(11) | NO   | PRI | NULL    | auto_increment |
    | user_id   | int(11) | YES  |     | NULL    |                |
    | blog_like | int(11) | YES  |     | 0       |                |
    +-----------+---------+------+-----+---------+----------------+
    4 rows in set (0.00 sec)
    






SQL stored procedures

Here is the list of the stored procedures:

mysql> SHOW PROCEDURE STATUS WHERE db = 'FlaskBlogApp';
+--------------+-------------------+-----------+----------------+---------------------+---------------------+---------------+---------+----------------------+----------------------+--------------------+
| Db           | Name              | Type      | Definer        | Modified            | Created             | Security_type | Comment | character_set_client | collation_connection | Database Collation |
+--------------+-------------------+-----------+----------------+---------------------+---------------------+---------------+---------+----------------------+----------------------+--------------------+
| FlaskBlogApp | sp_addBlog        | PROCEDURE | root@localhost | 2016-12-12 08:22:42 | 2016-12-12 08:22:42 | DEFINER       |         | utf8                 | utf8_general_ci      | latin1_swedish_ci  |
| FlaskBlogApp | sp_AddUpdateLikes | PROCEDURE | root@localhost | 2016-12-13 21:41:21 | 2016-12-13 21:41:21 | DEFINER       |         | utf8                 | utf8_general_ci      | latin1_swedish_ci  |
| FlaskBlogApp | sp_createUser     | PROCEDURE | root@localhost | 2016-12-13 11:20:21 | 2016-12-13 11:20:21 | DEFINER       |         | utf8                 | utf8_general_ci      | latin1_swedish_ci  |
| FlaskBlogApp | sp_deleteBlog     | PROCEDURE | root@localhost | 2016-12-05 16:28:27 | 2016-12-05 16:28:27 | DEFINER       |         | utf8                 | utf8_general_ci      | latin1_swedish_ci  |
| FlaskBlogApp | sp_GetAllBlogs    | PROCEDURE | root@localhost | 2016-12-13 08:46:38 | 2016-12-13 08:46:38 | DEFINER       |         | utf8                 | utf8_general_ci      | latin1_swedish_ci  |
| FlaskBlogApp | sp_GetBlogById    | PROCEDURE | root@localhost | 2016-12-11 13:01:14 | 2016-12-11 13:01:14 | DEFINER       |         | utf8                 | utf8_general_ci      | latin1_swedish_ci  |
| FlaskBlogApp | sp_GetBlogByUser  | PROCEDURE | root@localhost | 2016-12-10 08:35:08 | 2016-12-10 08:35:08 | DEFINER       |         | utf8                 | utf8_general_ci      | latin1_swedish_ci  |
| FlaskBlogApp | sp_getLikeStatus  | PROCEDURE | root@localhost | 2016-12-13 08:52:50 | 2016-12-13 08:52:50 | DEFINER       |         | utf8                 | utf8_general_ci      | latin1_swedish_ci  |
| FlaskBlogApp | sp_updateBlog     | PROCEDURE | root@localhost | 2016-12-11 13:03:07 | 2016-12-11 13:03:07 | DEFINER       |         | utf8                 | utf8_general_ci      | latin1_swedish_ci  |
| FlaskBlogApp | sp_validateLogin  | PROCEDURE | root@localhost | 2016-12-04 04:09:38 | 2016-12-04 04:09:38 | DEFINER       |         | utf8                 | utf8_general_ci      | latin1_swedish_ci  |
+--------------+-------------------+-----------+----------------+---------------------+---------------------+---------------+---------+----------------------+----------------------+--------------------+
10 rows in set (0.08 sec)

Or we can get simpler output:

mysql> select db,name,definer,modified from mysql.proc WHERE db = 'FlaskBlogApp';
+--------------+-------------------+----------------+---------------------+
| db           | name              | definer        | modified            |
+--------------+-------------------+----------------+---------------------+
| FlaskBlogApp | getSum            | root@localhost | 2016-12-12 08:23:03 |
| FlaskBlogApp | hasLiked          | root@localhost | 2016-12-13 08:35:27 |
| FlaskBlogApp | sp_addBlog        | root@localhost | 2016-12-12 08:22:42 |
| FlaskBlogApp | sp_AddUpdateLikes | root@localhost | 2016-12-13 21:41:21 |
| FlaskBlogApp | sp_createUser     | root@localhost | 2016-12-13 11:20:21 |
| FlaskBlogApp | sp_deleteBlog     | root@localhost | 2016-12-05 16:28:27 |
| FlaskBlogApp | sp_GetAllBlogs    | root@localhost | 2016-12-13 08:46:38 |
| FlaskBlogApp | sp_GetBlogById    | root@localhost | 2016-12-11 13:01:14 |
| FlaskBlogApp | sp_GetBlogByUser  | root@localhost | 2016-12-10 08:35:08 |
| FlaskBlogApp | sp_getLikeStatus  | root@localhost | 2016-12-13 08:52:50 |
| FlaskBlogApp | sp_updateBlog     | root@localhost | 2016-12-11 13:03:07 |
| FlaskBlogApp | sp_validateLogin  | root@localhost | 2016-12-04 04:09:38 |
+--------------+-------------------+----------------+---------------------+
12 rows in set (0.00 sec)

To see a specific PROCEDURE:

MariaDB [FlaskBlogApp]> SHOW CREATE PROCEDURE sp_deleteBlog;
+---------------+----------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------+----------------------+--------------------+
| Procedure     | sql_mode | Create Procedure                                                                                                                                                                               | character_set_client | collation_connection | Database Collation |
+---------------+----------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------+----------------------+--------------------+
| sp_deleteBlog |          | CREATE DEFINER=`root`@`localhost` PROCEDURE `sp_deleteBlog`(
IN p_blog_id bigint,
IN p_user_id bigint
)
BEGIN
delete from tbl_blog where blog_id = p_blog_id and blog_user_id = p_user_id;
END | utf8                 | utf8_general_ci      | latin1_swedish_ci  |
+---------------+----------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------+----------------------+--------------------+
1 row in set (0.00 sec)

To see a specific FUNCTION:

MariaDB [FlaskBlogApp]> SHOW CREATE FUNCTION getSum;



Here are the stored procedures:

  1. getSum:
    USE `FlaskBlogApp`;
    DROP FUNCTION IF EXISTS getSum;
    
    DELIMITER $$
    CREATE DEFINER=`root`@`localhost` FUNCTION `getSum`(
        p_blog_id int
    ) RETURNS int(11)
    BEGIN
        select sum(blog_like) into @sm from tbl_likes where blog_id = p_blog_id;
    RETURN @sm;
    END$$
    DELIMITER ;
    

  2. hasLiked:
    USE `FlaskBlogApp`;
    DROP Function IF EXISTS `hasLiked`;
    
    DELIMITER $$
    CREATE DEFINER=`root`@`localhost` FUNCTION `hasLiked`(
        p_blog int,
        p_user int
    ) RETURNS int(11)
    BEGIN  
        select blog_like into @myval from tbl_likes where blog_id =  p_blog and user_id = p_user;
    RETURN @myval;
    END$$
    DELIMITER ;
    

  3. sp_addBlog:
    USE `FlaskBlogApp`;
    DROP procedure IF EXISTS `sp_addBlog`;
     
    DELIMITER $$
    USE `FlaskBlogApp`$$
    CREATE DEFINER=`root`@`localhost` PROCEDURE `sp_addBlog`(
        IN p_title varchar(45),
        IN p_description varchar(1000),
        IN p_user_id bigint,
        IN p_file_path varchar(200),
        IN p_is_private int,
        IN p_is_done int
    )
    BEGIN
        insert into tbl_blog(
            blog_title,
            blog_description,
            blog_user_id,
            blog_date,
            blog_file_path,
            blog_private,
            blog_accomplished
        )
        values
        (
            p_title,
            p_description,
            p_user_id,
            NOW(),
            p_file_path,
            p_is_private,
            p_is_done
        );
    END$$
     
    DELIMITER ;
    

  4. sp_createUser:
    USE `FlaskBlogApp`;
    DROP procedure IF EXISTS `sp_createUser`;
    
    DELIMITER $$
    CREATE DEFINER=`root`@`localhost` PROCEDURE `sp_createUser`(
        IN p_name VARCHAR(20),
        IN p_username VARCHAR(20),
        IN p_password VARCHAR(85)
    )
    BEGIN
        IF ( select exists (select 1 from blog_user where user_username = p_username) ) THEN
         
            select 'Username Exists !!';
         
        ELSE
         
            insert into blog_user
            (
                user_name,
                user_username,
                user_password
            )
            values
            (
                p_name,
                p_username,
                p_password
            );
         
        END IF;
    END$$
    DELIMITER ;
    

  5. sp_deleteBlog:
    USE `FlaskBlogApp`;
    DROP procedure IF EXISTS `sp_deleteBlog`;
    
    DELIMITER $$
    USE `FlaskBlogApp`$$
    CREATE PROCEDURE `sp_deleteBlog` (
    IN p_blog_id bigint,
    IN p_user_id bigint
    )
    BEGIN
    delete from tbl_blog where blog_id = p_blog_id and blog_user_id = p_user_id;
    END$$
     
    DELIMITER ;
    

  6. sp_GetAllBlogs:
    USE `FlaskBlogApp`;
    DROP procedure IF EXISTS `sp_GetAllBlogs`;
     
    DELIMITER $$
    USE `FlaskBlogApp`$$
    CREATE DEFINER=`root`@`localhost` PROCEDURE `sp_GetAllBlogs`()
    BEGIN
        select blog_id,blog_title,blog_description,blog_file_path from tbl_blog where blog_private = 0;
    END$$
     
    DELIMITER ;
    

  7. sp_GetBlogById:
    USE `FlaskBlogApp`;
    DROP procedure IF EXISTS `sp_GetBlogById`;
    
    DELIMITER $$
    USE `FlaskBlogApp`$$
    
    CREATE DEFINER=`root`@`localhost` PROCEDURE `sp_GetBlogById`(
    IN p_blog_id bigint,
    In p_user_id bigint
    )
    BEGIN
    select blog_id,blog_title,blog_description,blog_file_path,blog_private,blog_accomplished from tbl_blog where blog_id = p_blog_id and blog_user_id = p_user_id;
    END$$
     
    DELIMITER ;
    

  8. sp_GetBlogByUser:
    USE `FlaskBlogApp`;
    DROP procedure IF EXISTS `sp_GetBlogByUser`;
     
    DELIMITER $$
    USE `FlaskBlogApp`$$
    CREATE PROCEDURE `sp_GetBlogByUser` (
    IN p_user_id bigint
    )
    BEGIN
        select * from tbl_blog where blog_user_id = p_user_id;
    END$$
     
    DELIMITER ;
    

  9. sp_getLikeStatus:
    USE `FlaskBlogApp`;
    DROP procedure IF EXISTS `sp_getLikeStatus`;
    
    DELIMITER $$
    CREATE DEFINER=`root`@`localhost` PROCEDURE `sp_getLikeStatus`(
        IN p_blog_id int,
        IN p_user_id int
    )
    BEGIN
        select getSum(p_blog_id),hasLiked(p_blog_id,p_user_id);
    END$$
    DELIMITER ;
    

  10. sp_AddUpdateLikes:
    USE `FlaskBlogApp`;
    DROP procedure IF EXISTS `sp_AddUpdateLikes`;
    
    DELIMITER $$
     
    CREATE DEFINER=`root`@`localhost` PROCEDURE `sp_AddUpdateLikes`(
        p_blog_id int,
        p_user_id int,
        p_like int
    )
    BEGIN
        if (select exists (select 1 from tbl_likes where blog_id = p_blog_id and user_id = p_user_id)) then
     
            update tbl_likes set blog_like = p_like where blog_id = p_blog_id and user_id = p_user_id;
             
        else
             
            insert into tbl_likes(
                blog_id,
                user_id,
                blog_like
            )
            values(
                p_blog_id,
                p_user_id,
                p_like
            );
     
        end if;
    END$$
    
    DELIMITER ;
    

  11. sp_updateBlog:
    USE `FlaskBlogApp`;
    DROP procedure IF EXISTS `sp_updateBlog`;
     
    DELIMITER $$
    USE `FlaskBlogApp`$$
    CREATE DEFINER=`root`@`localhost` PROCEDURE `sp_updateBlog`(
    IN p_title varchar(45),
    IN p_description varchar(1000),
    IN p_blog_id bigint,
    In p_user_id bigint,
    IN p_file_path varchar(200),
    IN p_is_private int,
    IN p_is_done int
    )
    BEGIN
    update tbl_blog set
        blog_title = p_title,
        blog_description = p_description,
        blog_file_path = p_file_path,
        blog_private = p_is_private,
        blog_accomplished = p_is_done
        where blog_id = p_blog_id and blog_user_id = p_user_id;
    END$$
     
    DELIMITER ;
    

  12. sp_validateLogin:
    USE `FlaskBlogApp`;
    DROP procedure IF EXISTS `sp_validateLogin`;
    
    
    DELIMITER $$
    CREATE DEFINER=`root`@`localhost` PROCEDURE `sp_validateLogin`(
    IN p_username VARCHAR(20)
    )
    BEGIN
    	select * from blog_user where user_username = p_username;
    END$$
    
    DELIMITER ;
    







Ph.D. / Golden Gate Ave, San Francisco / Seoul National Univ / Carnegie Mellon / UC Berkeley / DevOps / Deep Learning / Visualization

YouTubeMy YouTube channel

Sponsor Open Source development activities and free contents for everyone.

Thank you.

- K Hong








Flask



Deploying Flask Hello World App with Apache WSGI on Ubuntu 14

Flask Micro blog "Admin App" with Postgresql

Flask "Blog App" with MongoDB - Part 1 (Local via Flask server)

Flask "Blog App" with MongoDB on Ubuntu 14 - Part 2 (Local Apache WSGI)

Flask "Blog App" with MongoDB on CentOS 7 - Part 3 (Production Apache WSGI )

Flask word count app 1 with PostgreSQL and Flask-SQLAlchemy

Flask word count app 2 via BeautifulSoup, and Natural Language Toolkit (NLTK) with Gunicorn/PM2/Apache

Flask word count app 3 with Redis task queue

Flask word count app 4 with AngularJS polling the back-end

Flask word count app 5 with AngularJS front-end updates and submit error handling

Flask word count app 0 - Errors and Fixes

Flask with Embedded Machine Learning I : Serializing with pickle and DB setup

Flask with Embedded Machine Learning II : Basic Flask App

Flask with Embedded Machine Learning III : Embedding Classifier

Flask with Embedded Machine Learning IV : Deploy

Flask with Embedded Machine Learning V : Updating the classifier

Flask AJAX with jQuery

Flask blog app with Dashboard 1 - SignUp page

Flask blog app with Dashboard 2 - Sign-In / Sign-Out

Flask blog app with Dashboard 3 - Adding blog post item

Flask blog app with Dashboard 4 - Update / Delete

Flask blog app with Dashboard 5 - Uploading an image

Flask blog app with Dashboard 6 - Dash board

Flask blog app with Dashboard 7 - Like button

Flask blog app with Dashboard 8 - Deploy

Flask blog app with Dashboard - Appendix (tables and mysql stored procedures/functions

Sponsor Open Source development activities and free contents for everyone.

Thank you.

- K Hong






Python tutorial



Python Home

Introduction

Running Python Programs (os, sys, import)

Modules and IDLE (Import, Reload, exec)

Object Types - Numbers, Strings, and None

Strings - Escape Sequence, Raw String, and Slicing

Strings - Methods

Formatting Strings - expressions and method calls

Files and os.path

Traversing directories recursively

Subprocess Module

Regular Expressions with Python

Regular Expressions Cheat Sheet

Object Types - Lists

Object Types - Dictionaries and Tuples

Functions def, *args, **kargs

Functions lambda

Built-in Functions

map, filter, and reduce

Decorators

List Comprehension

Sets (union/intersection) and itertools - Jaccard coefficient and shingling to check plagiarism

Hashing (Hash tables and hashlib)

Dictionary Comprehension with zip

The yield keyword

Generator Functions and Expressions

generator.send() method

Iterators

Classes and Instances (__init__, __call__, etc.)

if__name__ == '__main__'

argparse

Exceptions

@static method vs class method

Private attributes and private methods

bits, bytes, bitstring, and constBitStream

json.dump(s) and json.load(s)

Python Object Serialization - pickle and json

Python Object Serialization - yaml and json

Priority queue and heap queue data structure

Graph data structure

Dijkstra's shortest path algorithm

Prim's spanning tree algorithm

Closure

Functional programming in Python

Remote running a local file using ssh

SQLite 3 - A. Connecting to DB, create/drop table, and insert data into a table

SQLite 3 - B. Selecting, updating and deleting data

MongoDB with PyMongo I - Installing MongoDB ...

Python HTTP Web Services - urllib, httplib2

Web scraping with Selenium for checking domain availability

REST API : Http Requests for Humans with Flask

Blog app with Tornado

Multithreading ...

Python Network Programming I - Basic Server / Client : A Basics

Python Network Programming I - Basic Server / Client : B File Transfer

Python Network Programming II - Chat Server / Client

Python Network Programming III - Echo Server using socketserver network framework

Python Network Programming IV - Asynchronous Request Handling : ThreadingMixIn and ForkingMixIn

Python Coding Questions I

Python Coding Questions II

Python Coding Questions III

Python Coding Questions IV

Python Coding Questions V

Python Coding Questions VI

Python Coding Questions VII

Python Coding Questions VIII

Python Coding Questions IX

Python Coding Questions X

Image processing with Python image library Pillow

Python and C++ with SIP

PyDev with Eclipse

Matplotlib

Redis with Python

NumPy array basics A

NumPy Matrix and Linear Algebra

Pandas with NumPy and Matplotlib

Celluar Automata

Batch gradient descent algorithm

Longest Common Substring Algorithm

Python Unit Test - TDD using unittest.TestCase class

Simple tool - Google page ranking by keywords

Google App Hello World

Google App webapp2 and WSGI

Uploading Google App Hello World

Python 2 vs Python 3

virtualenv and virtualenvwrapper

Uploading a big file to AWS S3 using boto module

Scheduled stopping and starting an AWS instance

Cloudera CDH5 - Scheduled stopping and starting services

Removing Cloud Files - Rackspace API with curl and subprocess

Checking if a process is running/hanging and stop/run a scheduled task on Windows

Apache Spark 1.3 with PySpark (Spark Python API) Shell

Apache Spark 1.2 Streaming

bottle 0.12.7 - Fast and simple WSGI-micro framework for small web-applications ...

Flask app with Apache WSGI on Ubuntu14/CentOS7 ...

Selenium WebDriver

Fabric - streamlining the use of SSH for application deployment

Ansible Quick Preview - Setting up web servers with Nginx, configure enviroments, and deploy an App

Neural Networks with backpropagation for XOR using one hidden layer

NLP - NLTK (Natural Language Toolkit) ...

RabbitMQ(Message broker server) and Celery(Task queue) ...

OpenCV3 and Matplotlib ...

Simple tool - Concatenating slides using FFmpeg ...

iPython - Signal Processing with NumPy

iPython and Jupyter - Install Jupyter, iPython Notebook, drawing with Matplotlib, and publishing it to Github

iPython and Jupyter Notebook with Embedded D3.js

Downloading YouTube videos using youtube-dl embedded with Python

Machine Learning : scikit-learn ...

Django 1.6/1.8 Web Framework ...









Contact

BogoToBogo
contactus@bogotobogo.com

Follow Bogotobogo

About Us

contactus@bogotobogo.com

YouTubeMy YouTube channel
Pacific Ave, San Francisco, CA 94115

Pacific Ave, San Francisco, CA 94115

Copyright © 2024, bogotobogo
Design: Web Master