# Flask Session

***

**1. Basic Usage**

```python
from flask import Flask, session

app = Flask(__name__)

# Set the secret key for session protection
app.secret_key = 'secret_key'

@app.route('/')
def index():
    # Create a session variable
    session['username'] = 'John Doe'

    return 'Session variable created'
```

**2. Accessing Session Variables**

```python
@app.route('/')
def index():
    # Get the session variable
    username = session.get('username')

    return f'Username: {username}'
```

**3. Modifying Session Variables**

```python
@app.route('/')
def index():
    # Modify the session variable
    session['username'] = 'Jane Doe'

    return 'Session variable modified'
```

**4. Deleting Session Variables**

```python
@app.route('/')
def index():
    # Delete the session variable
    del session['username']

    return 'Session variable deleted'
```

**5. Clearing the Session**

```python
@app.route('/')
def index():
    # Clear the session
    session.clear()

    return 'Session cleared'
```

**6. Using Permanent Sessions**

```python
@app.route('/')
def index():
    # Create a permanent session variable
    session.permanent = True
    session['username'] = 'John Doe'

    return 'Permanent session variable created'
```

**7. Setting Session Expiration Time**

```python
@app.route('/')
def index():
    # Set the session expiration time
    app.permanent_session_lifetime = timedelta(minutes=30)

    return 'Session expiration time set'
```

**8. Custom Session Store**

```python
from flask.sessions import SessionInterface, SessionMixin
from werkzeug.datastructures import CallbackDict

class CustomSessionInterface(SessionInterface):

    def open_session(self, app, request):
        return CallbackDict()

    def save_session(self, app, session, response):
        pass

app.session_interface = CustomSessionInterface()
```

**9. Session Middleware**

```python
from flask.sessions import SessionMiddleware

app.wsgi_app = SessionMiddleware(app)
```

**10. Using a Session Variable as a Context Processor**

```python
@app.context_processor
def inject_session():
    return dict(session=session)
```

**11. Session with SQLAlchemy**

```python
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy(app)

class Session(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    data = db.Column(db.String(1000))

@app.route('/')
def index():
    # Create a session object
    session = Session(data='{"username": "John Doe"}')
    db.session.add(session)
    db.session.commit()

    return 'Session with SQLAlchemy created'
```

**12. Using a Redis Session Store**

```python
from flask_session import Session

Session(app)
```

**13. Session with Redis using Flask-Redis**

```python
from flask_redis import FlaskRedis

redis = FlaskRedis()

@app.route('/')
def index():
    # Create a Redis session variable
    redis.set('username', 'John Doe')

    return 'Session with Redis using Flask-Redis created'
```

**14. Session with MongoDB using Flask-Mongoengine**

```python
from flask_mongoengine import MongoEngine

db = MongoEngine()

class Session(db.Document):
    username = db.StringField()

@app.route('/')
def index():
    # Create a Session document
    session = Session(username='John Doe')
    session.save()

    return 'Session with MongoDB using Flask-Mongoengine created'
```

**15. Session with Elasticsearch using Flask-Elasticsearch**

```python
from flask_elasticsearch import FlaskElasticsearch

es = FlaskElasticsearch()

@app.route('/')
def index():
    # Create an Elasticsearch session variable
    es.index(index='my_index', doc_type='session', id='1', body={'username': 'John Doe'})

    return 'Session with Elasticsearch using Flask-Elasticsearch created'
```

**16. Session with Memcached using Flask-Memcached**

```python
from flask_memcached import FlaskMemcached

memcache = FlaskMemcached()

@app.route('/')
def index():
    # Create a Memcached session variable
    memcache.set('username', 'John Doe')

    return 'Session with Memcached using Flask-Memcached created'
```

**17. Session with ScyllaDB using Flask-ScyllaDB**

```python
from flask_scylladb import FlaskScyllaDB

db = FlaskScyllaDB()

@app.route('/')
def index():
    # Create a ScyllaDB session variable
    db.session.execute('INSERT INTO sessions (key, data) VALUES (%s, %s)', ('username', 'John Doe'))

    return 'Session with ScyllaDB using Flask-ScyllaDB created'
```

**18. Session with Cassandra using Flask-Cassandra**

```python
from flask_cassandra import FlaskCassandra

db = FlaskCassandra()

@app.route('/')
def index():
    # Create a Cassandra session variable
    db.session.execute('INSERT INTO sessions (key, data) VALUES (%s, %s)', ('username', 'John Doe'))

    return 'Session with Cassandra using Flask-Cassandra created'
```

**19. Session with CosmosDB using Flask-CosmosDB**

```python
from flask_cosmosdb import FlaskCosmosDB

db = FlaskCosmosDB()

@app.route('/')
def index():
    # Create a CosmosDB session variable
    db.session.execute('INSERT INTO sessions (key, data) VALUES (%s, %s)', ('username', 'John Doe'))

    return 'Session with CosmosDB using Flask-CosmosDB created'
```

**20. Session with MongoDB using Flask-PyMongo**

```python
from flask_pymongo import PyMongo

mongo = PyMongo(app)

@app.route('/')
def index():
    # Create a MongoDB session variable
    mongo.db.sessions.insert_one({'username': 'John Doe'})

    return 'Session with MongoDB using Flask-PyMongo created'
```

**21. Session with Apache Cassandra using Flask-AioCassandra**

```python
from flask_aiocassandra import FlaskAioCassandra

db = FlaskAioCassandra()

@app.route('/')
async def index():
    # Create an Apache Cassandra session variable
    await db.session.execute('INSERT INTO sessions (key, data) VALUES (%s, %s)', ('username', 'John Doe'))

    return 'Session with Apache Cassandra using Flask-AioCassandra created'
```

**22. Session with PostgreSQL using Flask-SQLAlchemy**

```python
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy(app)

class Session(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(100))

@app.route('/')
def index():
    # Create a PostgreSQL session variable
    session = Session(username='John Doe')
    db.session.add(session)
    db.session.commit()

    return 'Session with PostgreSQL using Flask-SQLAlchemy created'
```

**23. Session with MongoDB using Flask-Motor**

```python
from flask_motor import Motor

db = Motor(app)

@app.route('/')
def index():
    # Create a MongoDB session variable
    db.sessions.insert_one({'username': 'John Doe'})

    return 'Session with MongoDB using Flask-Motor created'
```

**24. Session with Redis using Flask-Redis**

```python
from flask_redis import FlaskRedis

redis = FlaskRedis(app)

@app.route('/')
def index():
    # Create a Redis session variable
    redis.set('username', 'John Doe')

    return 'Session with Redis using Flask-Redis created'
```

**25. Session with Memcached using Flask-Memcached**

```python
from flask_memcached import FlaskMemcached

memcache = FlaskMemcached(app)

@app.route('/')
def index():
    # Create a Memcached session variable
    memcache.set('username', 'John Doe')

    return 'Session with Memcached using Flask-Memcached created'
```

**26. Session with Apache Cassandra using Flask-Cassino**

```python
from flask_cassino import FlaskCassino

db = FlaskCassino(app)

@app.route('/')
def index():
    # Create an Apache Cassandra session variable
    db.session.execute('INSERT INTO sessions (key, data) VALUES (%s, %s)', ('username', 'John Doe'))

    return 'Session with Apache Cassandra using Flask-Cassino created'
```

**27. Session with Neo4j using Flask-Neo4j**

```python
from flask_neo4j import FlaskNeo4j

db = FlaskNeo4j(app)

@app.route('/')
def index():
    # Create a Neo4j session variable
    db.session.run('CREATE (n:Person {username: "John Doe"})')

    return 'Session with Neo4j using Flask-Neo4j created'
```

**28. Session with MongoDB using Flask-Mongoengine**

```python
from flask_mongoengine import MongoEngine

db = MongoEngine(app)

class Session(db.Document):
    username = db.StringField()

@app.route('/')
def index():
    # Create a MongoDB session variable
    session = Session(username='John Doe')
    session.save()

    return 'Session with MongoDB using Flask-Mongoengine created'
```

**29. Session with Postgres using Flask-SQLAlchemy**

```python
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy(app)

class Session(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(100))

@app.route('/')
def index():
    # Create a PostgreSQL session variable
    session = Session(username='John Doe')
    db.session.add(session)
    db.session.commit()

    return 'Session with PostgreSQL using Flask-SQLAlchemy created'
```

**30. Session with MariaDB using Flask-SQLAlchemy**

```python
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy(app)

class Session(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(100))

@app.route('/')
def index():
    # Create a MariaDB session variable
    session = Session(username='John Doe')
    db.session.add(session)
    db.session.commit()

    return 'Session with MariaDB using Flask-SQLAlchemy created'
```

**31. Session with Oracle using Flask-SQLAlchemy**

```python
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy(app)

class Session(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(100))

@app.route('/')
def index():
    # Create an Oracle session variable
    session = Session(username='John Doe')
    db.session.add(session)
    db.session.commit()

    return 'Session with Oracle using Flask-SQLAlchemy created'
```

**32. Session with Microsoft SQL Server using Flask-SQLAlchemy**

```python
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy(app)

class Session(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(100))

@app.route('/')
def index():
    # Create a Microsoft SQL Server session variable
    session = Session(username='John Doe')
    db.session.add(session)
    db.session.commit()

    return 'Session with Microsoft SQL Server using Flask-SQLAlchemy created'
```

**33. Session with SQLite using Flask-SQLAlchemy**

```python
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy(app)

class Session(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(100))

@app.route('/')
def index():
    # Create a SQLite session variable
    session = Session(username='John Doe')
    db.session.add(session)
    db.session.commit()

    return 'Session with SQLite using Flask-SQLAlchemy created'
```

**34. Session with MySQL using Flask-SQLAlchemy**

```python
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy(app)

class Session(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(100))

@app.route('/')
def index():
    # Create a MySQL session variable
    session = Session(username='John Doe')
    db.session.add(session)
    db.session.commit()

    return 'Session with MySQL using Flask-SQLAlchemy created'
```

**35. Session with PostgreSQL using Flask-PostgreSQL**

```python
from flask_postgresql import PostgreSQL

db = PostgreSQL(app)

@app.route('/')
def index():
    # Create a PostgreSQL session variable
    db.execute('INSERT INTO sessions (username) VALUES (%s)', ('John Doe',))
    db.commit()

    return 'Session with PostgreSQL using Flask-PostgreSQL created'
```

**36. Session with MongoDB using Flask-PyMongo**

```python
from flask_pymongo import PyMongo

mongo = PyMongo(app)

@app.route('/')
def index():
    # Create a MongoDB session variable
    mongo.db.sessions.insert_one({'username': 'John Doe'})

    return 'Session with MongoDB using Flask-PyMongo created'

```