Tkinter SQLite Stock Tracker and Data Viewer

Q: Why does the viewer limit the result to 500 rows?

Limiting the first Treeview display helps keep the interface responsive. Pagination or date filters can be added later.

This project extends our Tkinter real-time data tracker by adding persistent storage with SQLite.

The project has two parts.

Fetch the latest available stock price, save each observation in SQLite and update a Matplotlib graph.
Open the stored database records in a second Tkinter application and display them using a Treeview.

The worker thread performs only the external data request. Results are sent through a Queue so database writes, StringVar updates and Matplotlib drawing remain on the Tkinter main thread.

Stock data note: The example displays the latest available intraday value returned by the data source. It should not be treated as guaranteed exchange-level real-time data.

External data
      |
      v
Worker thread
      |
      v
Queue
      |
      v
Tkinter main thread
      |
      +--> SQLite
      |
      +--> Matplotlib
      |
      +--> Labels

SQLite
  |
  v
Combobox
  |
  v
Treeview viewer

Show Table of Contents

Part I: Track and Store Stock Data
Libraries Used
Create the SQLite Database
Fetch the Latest Available Price
Use a Worker Thread and Queue
Save the Price in SQLite
Update the Matplotlib Graph
Start and Stop Tracking
Complete Tracker Code
Part II: Display Stored Data
Populate the Stock Combobox
Display SQLite Rows in Treeview
Complete Viewer Code
Project Improvements
FAQs

Tkinter stock tracker storing stock price data in SQLite database

Real-Time Stock Data Viewer with SQLite and Tkinter

Part I: Track and Store Stock Data Top ↑

The first application combines Tkinter, threading, SQLite and Matplotlib.

The program lets the user choose one of several Indian stocks or market indices from a Combobox.

After tracking starts, Python periodically:

fetches the latest available value;
sends it from the worker thread to the Tkinter main thread;
stores it in SQLite;
adds it to the graph;
schedules the next request.

Libraries Used Top ↑

import queue
import sqlite3
import threading
import tkinter as tk

from tkinter import ttk

import yfinance as yf

from matplotlib.figure import Figure

from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg

The main roles are:

Tkinter: desktop interface.
threading: runs the network request without blocking the GUI.
Queue: passes the worker result to the Tkinter main thread.
SQLite: stores historical observations.
Matplotlib: plots the collected values.

Create the SQLite Database Top ↑

The database file is stored in the same directory as the Python program.

db_path=os.path.join(
    os.path.dirname(
        os.path.abspath(__file__)
    ),
    'stock_data.db'
)

The table keeps the same columns as the earlier version of this project so an existing database remains compatible.

def create_database():

    with sqlite3.connect(db_path) as conn:

        conn.execute(
            '''CREATE TABLE IF NOT EXISTS stock_prices (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                stock_name TEXT NOT NULL,
                price REAL NOT NULL,
                timestamp TEXT NOT NULL
            )'''
        )

        conn.execute(
            '''CREATE INDEX IF NOT EXISTS
            idx_stock_prices_name_id
            ON stock_prices(stock_name,id)'''
        )

The index helps when the viewer requests records for one stock ordered by their ID.

Fetch the Latest Available Price Top ↑

The fetching function is independent of Tkinter and SQLite.

def fetch_stock_price(ticker):

    stock=yf.Ticker(ticker)

    data=stock.history(
        period='1d',
        interval='1m'
    )

    if data.empty:

        raise ValueError(
            'No intraday data was returned.'
        )

    close_values=data['Close'].dropna()

    if close_values.empty:

        raise ValueError(
            'No price data is available.'
        )

    price=float(
        close_values.iloc[-1]
    )

    timestamp=close_values.index[-1]

    return price,timestamp

Use a Worker Thread and Queue Top ↑

The worker performs only the potentially slow external request.

def fetch_worker(
    tracker_id,
    ticker,
    stock_name
):

    try:

        price,timestamp=fetch_stock_price(
            ticker
        )

        result_queue.put(
            (
                'ok',
                tracker_id,
                stock_name,
                price,
                timestamp
            )
        )

    except Exception as e:

        result_queue.put(
            (
                'error',
                tracker_id,
                stock_name,
                str(e),
                None
            )
        )

tracker_id identifies the current tracking session. If the user changes stocks before an older request finishes, that older result can be ignored.

The worker thread should not call canvas.draw(), StringVar.set() or other Tkinter methods directly.

Save Stock Data in SQLite Top ↑

When the main Tkinter thread receives a successful worker result, the record is inserted using parameters.

def save_to_database(
    stock_name,
    price,
    timestamp
):

    with sqlite3.connect(db_path) as conn:

        conn.execute(
            '''INSERT INTO stock_prices
            (stock_name,price,timestamp)
            VALUES (?,?,?)''',
            (
                stock_name,
                price,
                timestamp
            )
        )

The timestamp stored is the timestamp associated with the returned market data rather than simply the computer's current clock time.

Update the Matplotlib Graph Top ↑

Matplotlib is embedded in Tkinter using FigureCanvasTkAgg.

The graph is updated only from the Tkinter main thread.

def plot_graph(stock_name):

    ax.clear()

    ax.plot(
        times,
        prices,
        marker='o'
    )

    ax.set_title(
        f'Latest Price Data - {stock_name}'
    )

    ax.set_xlabel(
        'Time'
    )

    ax.set_ylabel(
        'Price / Index Value'
    )

    fig.autofmt_xdate()

    canvas.draw_idle()

The example keeps only the latest 60 plotted points so the in-memory graph does not grow indefinitely.

Start and Stop Tracking Top ↑

Starting another stock does not call thread.join() from the GUI thread.

Instead, the application increments the tracking-session ID and starts a new request.

tracker_id+=1

If an old worker returns later, its ID no longer matches the active session and the result is ignored.

This keeps the GUI responsive even if the previous network request takes time to finish.

Complete Tracker and SQLite Storage Program Top ↑

import os
import queue
import sqlite3
import threading
import tkinter as tk
from tkinter import ttk

import yfinance as yf

from matplotlib.figure import Figure
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg

REFRESH_MS=60000
MAX_POINTS=60

stock_options={
    'Reliance Industries':'RELIANCE.NS',
    'Tata Consultancy Services (TCS)':'TCS.NS',
    'Infosys':'INFY.NS',
    'HDFC Bank':'HDFCBANK.NS',
    'ICICI Bank':'ICICIBANK.NS',
    'State Bank of India (SBI)':'SBIN.NS',
    'Bharti Airtel':'BHARTIARTL.NS',
    'Adani Enterprises':'ADANIENT.NS',
    'NSE Nifty 50 Index':'^NSEI',
    'BSE Sensex Index':'^BSESN'
}

db_path=os.path.join(
    os.path.dirname(
        os.path.abspath(__file__)
    ),
    'stock_data.db'
)

result_queue=queue.Queue()

tracking=False
worker_running=False
tracker_id=0
schedule_id=None

times=[]
prices=[]

def create_database():

with sqlite3.connect(db_path) as conn:

conn.execute(
            '''CREATE TABLE IF NOT EXISTS stock_prices (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                stock_name TEXT NOT NULL,
                price REAL NOT NULL,
                timestamp TEXT NOT NULL
            )'''
        )

conn.execute(
            '''CREATE INDEX IF NOT EXISTS
            idx_stock_prices_name_id
            ON stock_prices(stock_name,id)'''
        )

def fetch_stock_price(ticker):

stock=yf.Ticker(ticker)

data=stock.history(
        period='1d',
        interval='1m'
    )

if data.empty:

raise ValueError(
            'No intraday data was returned.'
        )

close_values=data['Close'].dropna()

if close_values.empty:

raise ValueError(
            'No price data is available.'
        )

price=float(
        close_values.iloc[-1]
    )

timestamp=close_values.index[-1]

return price,timestamp

def timestamp_to_text(timestamp):

if hasattr(
        timestamp,
        'isoformat'
    ):

return timestamp.isoformat()

return str(timestamp)

def timestamp_for_plot(timestamp):

if hasattr(
        timestamp,
        'to_pydatetime'
    ):

return timestamp.to_pydatetime()

return timestamp

def save_to_database(
    stock_name,
    price,
    timestamp
):

with sqlite3.connect(db_path) as conn:

conn.execute(
            '''INSERT INTO stock_prices
            (stock_name,price,timestamp)
            VALUES (?,?,?)''',
            (
                stock_name,
                price,
                timestamp
            )
        )

def fetch_worker(
    request_id,
    ticker,
    stock_name
):

try:

price,timestamp=fetch_stock_price(
            ticker
        )

result_queue.put(
            (
                'ok',
                request_id,
                stock_name,
                price,
                timestamp
            )
        )

except Exception as e:

result_queue.put(
            (
                'error',
                request_id,
                stock_name,
                str(e),
                None
            )
        )

root=tk.Tk()

root.title(
    'plus2net Stock Tracker with SQLite'
)

root.geometry(
    '900x650'
)

root.minsize(
    760,
    560
)

stock_var=tk.StringVar(
    value='Reliance Industries'
)

price_var=tk.StringVar(
    value='--'
)

time_var=tk.StringVar(
    value='No update yet'
)

status_var=tk.StringVar(
    value='Select a stock and start tracking.'
)

title_label=ttk.Label(
    root,
    text='Stock Tracker with SQLite Storage',
    font=('Arial',18,'bold')
)

title_label.pack(
    pady=(15,5)
)

selection_frame=ttk.Frame(root)

selection_frame.pack(
    pady=10
)

stock_dropdown=ttk.Combobox(
    selection_frame,
    textvariable=stock_var,
    values=list(
        stock_options.keys()
    ),
    state='readonly',
    width=36
)

stock_dropdown.grid(
    row=0,
    column=0,
    padx=5
)

button_frame=ttk.Frame(
    selection_frame
)

button_frame.grid(
    row=0,
    column=1,
    padx=5
)

ttk.Label(
    root,
    textvariable=price_var,
    font=('Arial',24,'bold')
).pack(
    pady=(5,2)
)

ttk.Label(
    root,
    textvariable=time_var
).pack()

fig=Figure(
    figsize=(8,4),
    dpi=100
)

ax=fig.add_subplot(111)

canvas=FigureCanvasTkAgg(
    fig,
    master=root
)

canvas.get_tk_widget().pack(
    fill=tk.BOTH,
    expand=True,
    padx=10,
    pady=10
)

ttk.Label(
    root,
    textvariable=status_var,
    wraplength=820
).pack(
    padx=10,
    pady=(0,12)
)

def plot_graph(stock_name):

ax.clear()

ax.plot(
        times,
        prices,
        marker='o'
    )

ax.set_title(
        f'Latest Price Data - {stock_name}'
    )

ax.set_xlabel(
        'Time'
    )

ax.set_ylabel(
        'Price / Index Value'
    )

ax.grid(True)

fig.autofmt_xdate()

canvas.draw_idle()

def schedule_next_fetch():

global schedule_id

if tracking:

schedule_id=root.after(
            REFRESH_MS,
            start_fetch
        )

def start_fetch():

global worker_running

if not tracking:
        return

if worker_running:
        return

selected_stock=stock_var.get()

ticker=stock_options.get(
        selected_stock
    )

if ticker is None:

status_var.set(
            'Select a valid stock.'
        )

return

worker_running=True

status_var.set(
        f'Fetching {selected_stock}...'
    )

thread=threading.Thread(
        target=fetch_worker,
        args=(
            tracker_id,
            ticker,
            selected_stock
        ),
        daemon=True
    )

thread.start()

def process_queue():

global worker_running
    global times
    global prices

try:

while True:

result=result_queue.get_nowait()

result_type=result[0]
            result_id=result[1]
            stock_name=result[2]

if result_id!=tracker_id:

continue

worker_running=False

if result_type=='ok':

price=result[3]
                source_timestamp=result[4]

timestamp_text=timestamp_to_text(
                    source_timestamp
                )

save_to_database(
                    stock_name,
                    price,
                    timestamp_text
                )

times.append(
                    timestamp_for_plot(
                        source_timestamp
                    )
                )

prices.append(
                    price
                )

if len(times)>MAX_POINTS:

times=times[-MAX_POINTS:]
                    prices=prices[-MAX_POINTS:]

price_var.set(
                    f'{price:.2f}'
                )

if hasattr(
                    source_timestamp,
                    'strftime'
                ):

display_time=source_timestamp.strftime(
                        '%Y-%m-%d %H:%M:%S'
                    )

else:

display_time=str(
                        source_timestamp
                    )

time_var.set(
                    f'Latest data: {display_time}'
                )

status_var.set(
                    f'{stock_name} saved to SQLite.'
                )

plot_graph(
                    stock_name
                )

else:

error_message=result[3]

status_var.set(
                    f'Unable to fetch {stock_name}: '
                    f'{error_message}'
                )

schedule_next_fetch()

except queue.Empty:

pass

root.after(
        200,
        process_queue
    )

def start_tracking():

global tracking
    global tracker_id
    global schedule_id
    global worker_running
    global times
    global prices

selected_stock=stock_var.get()

if selected_stock not in stock_options:

status_var.set(
            'Select a valid stock.'
        )

return

tracking=True

tracker_id+=1

worker_running=False

times=[]
    prices=[]

if schedule_id is not None:

try:

root.after_cancel(
                schedule_id
            )

except tk.TclError:

pass

schedule_id=None

start_button.config(
        state=tk.DISABLED
    )

stop_button.config(
        state=tk.NORMAL
    )

stock_dropdown.config(
        state='disabled'
    )

ax.clear()

canvas.draw_idle()

start_fetch()

def stop_tracking():

global tracking
    global tracker_id
    global schedule_id
    global worker_running

tracking=False

tracker_id+=1

worker_running=False

if schedule_id is not None:

try:

root.after_cancel(
                schedule_id
            )

except tk.TclError:

pass

schedule_id=None

start_button.config(
        state=tk.NORMAL
    )

stop_button.config(
        state=tk.DISABLED
    )

stock_dropdown.config(
        state='readonly'
    )

status_var.set(
        'Tracking stopped.'
    )

def on_close():

global tracking
    global tracker_id
    global schedule_id

tracking=False

tracker_id+=1

if schedule_id is not None:

try:

root.after_cancel(
                schedule_id
            )

except tk.TclError:

pass

root.destroy()

start_button=ttk.Button(
    button_frame,
    text='Start Tracking',
    command=start_tracking
)

start_button.grid(
    row=0,
    column=0,
    padx=4
)

stop_button=ttk.Button(
    button_frame,
    text='Stop',
    command=stop_tracking,
    state=tk.DISABLED
)

stop_button.grid(
    row=0,
    column=1,
    padx=4
)

create_database()

root.protocol(
    'WM_DELETE_WINDOW',
    on_close
)

root.after(
    200,
    process_queue
)

root.mainloop()

Why Database and Graph Updates Stay on the Main Thread Top ↑

The older program performed both:

plot_graph(stock_name)
canvas.draw()

inside the worker thread.

The revised design keeps the worker focused on the external request and passes the result back to Tkinter.

Worker:
    fetch data

Main thread:
    save data
    update StringVar
    update graph

This also makes the project easier to extend because fetching, persistence and presentation have separate responsibilities.

Part II: Display Stored Stock Data Top ↑

Tkinter Treeview displaying stored stock price data from SQLite

The second application opens the same stock_data.db file and displays saved observations using a Treeview.

The user chooses a stock from a read-only Combobox.

The viewer then loads the latest stored records for that stock.

There is no need to hardcode the stock list in the viewer. We can ask SQLite which stock names are actually present.

def load_stock_names():

    with sqlite3.connect(db_path) as conn:

        rows=conn.execute(
            '''SELECT DISTINCT stock_name
            FROM stock_prices
            ORDER BY stock_name'''
        ).fetchall()

    stock_names=[
        row[0]
        for row in rows
    ]

    stock_dropdown['values']=stock_names

If no rows exist, the interface displays a message rather than trying to access stock_names[0].

Display Stored Records in Treeview Top ↑

The viewer uses explicit columns:

SELECT
    id,
    stock_name,
    price,
    timestamp
FROM stock_prices
WHERE stock_name=?
ORDER BY id DESC
LIMIT ?

The selected stock and limit are passed as parameters.

rows=conn.execute(
    query,
    (
        selected_stock,
        MAX_ROWS
    )
).fetchall()

The database ID is used as the Treeview iid.

tree.insert(
    '',
    tk.END,
    iid=str(row[0]),
    values=(
        row[1],
        f'{row[2]:.2f}',
        row[3]
    )
)

The example loads a maximum of 500 recent records so an old database with thousands of observations does not immediately insert every row into the GUI.

Complete SQLite Stock Data Viewer Top ↑

import os
import sqlite3
import tkinter as tk
from tkinter import ttk

MAX_ROWS=500

db_path=os.path.join(
    os.path.dirname(
        os.path.abspath(__file__)
    ),
    'stock_data.db'
)

root=tk.Tk()

root.title(
    'plus2net View Stored Stock Data'
)

root.geometry(
    '850x500'
)

root.minsize(
    700,
    420
)

root.columnconfigure(
    0,
    weight=1
)

root.rowconfigure(
    2,
    weight=1
)

stock_var=tk.StringVar()

status_var=tk.StringVar(
    value='Loading stocks...'
)

title_label=ttk.Label(
    root,
    text='Stored Stock Data',
    font=('Arial',18,'bold')
)

title_label.grid(
    row=0,
    column=0,
    sticky='w',
    padx=15,
    pady=(15,5)
)

selection_frame=ttk.Frame(
    root,
    padding=(15,10)
)

selection_frame.grid(
    row=1,
    column=0,
    sticky='ew'
)

ttk.Label(
    selection_frame,
    text='Stock:'
).grid(
    row=0,
    column=0,
    padx=(0,5)
)

stock_dropdown=ttk.Combobox(
    selection_frame,
    textvariable=stock_var,
    state='readonly',
    width=38
)

stock_dropdown.grid(
    row=0,
    column=1,
    padx=5
)

report_frame=ttk.Frame(
    root,
    padding=(15,5)
)

report_frame.grid(
    row=2,
    column=0,
    sticky='nsew'
)

report_frame.columnconfigure(
    0,
    weight=1
)

report_frame.rowconfigure(
    0,
    weight=1
)

tree=ttk.Treeview(
    report_frame,
    columns=(
        'stock',
        'price',
        'timestamp'
    ),
    show='headings',
    selectmode='browse'
)

tree.grid(
    row=0,
    column=0,
    sticky='nsew'
)

scrollbar=ttk.Scrollbar(
    report_frame,
    orient='vertical',
    command=tree.yview
)

scrollbar.grid(
    row=0,
    column=1,
    sticky='ns'
)

tree.configure(
    yscrollcommand=scrollbar.set
)

tree.heading(
    'stock',
    text='Stock Name'
)

tree.heading(
    'price',
    text='Price'
)

tree.heading(
    'timestamp',
    text='Timestamp'
)

tree.column(
    'stock',
    width=300,
    anchor='w'
)

tree.column(
    'price',
    width=110,
    anchor='e'
)

tree.column(
    'timestamp',
    width=260,
    anchor='center'
)

ttk.Label(
    root,
    textvariable=status_var
).grid(
    row=3,
    column=0,
    sticky='w',
    padx=15,
    pady=(5,15)
)

def clear_tree():

for iid in tree.get_children():

tree.delete(
            iid
        )

def display_data(
    event=None
):

clear_tree()

selected_stock=stock_var.get()

if not selected_stock:

status_var.set(
            'Select a stock.'
        )

return

try:

with sqlite3.connect(
            db_path
        ) as conn:

rows=conn.execute(
                '''SELECT
                    id,
                    stock_name,
                    price,
                    timestamp
                FROM stock_prices
                WHERE stock_name=?
                ORDER BY id DESC
                LIMIT ?''',
                (
                    selected_stock,
                    MAX_ROWS
                )
            ).fetchall()

except sqlite3.Error as e:

status_var.set(
            f'Database error: {e}'
        )

return

for row in rows:

tree.insert(
            '',
            tk.END,
            iid=str(
                row[0]
            ),
            values=(
                row[1],
                f'{row[2]:.2f}',
                row[3]
            )
        )

if rows:

status_var.set(
            f'Showing {len(rows)} latest records '
            f'for {selected_stock}.'
        )

else:

status_var.set(
            'No stored records for this stock.'
        )

def load_stock_names():

try:

with sqlite3.connect(
            db_path
        ) as conn:

rows=conn.execute(
                '''SELECT DISTINCT stock_name
                FROM stock_prices
                ORDER BY stock_name'''
            ).fetchall()

except sqlite3.Error as e:

stock_dropdown[
            'values'
        ]=[]

status_var.set(
            f'Database error: {e}'
        )

return

stock_names=[
        row[0]
        for row in rows
    ]

stock_dropdown[
        'values'
    ]=stock_names

if stock_names:

if stock_var.get() not in stock_names:

stock_var.set(
                stock_names[0]
            )

display_data()

else:

stock_var.set(
            ''
        )

clear_tree()

status_var.set(
            'No stock data is stored yet.'
        )

load_button=ttk.Button(
    selection_frame,
    text='Load Data',
    command=display_data
)

load_button.grid(
    row=0,
    column=2,
    padx=5
)

refresh_button=ttk.Button(
    selection_frame,
    text='Reload Stocks',
    command=load_stock_names
)

refresh_button.grid(
    row=0,
    column=3,
    padx=5
)

stock_dropdown.bind(
    '<<ComboboxSelected>>',
    display_data
)

load_stock_names()

root.mainloop()

How This Version Improves the Original Project Top ↑

GUI Updates Stay on the Main Thread

The worker does not draw Matplotlib graphs or modify Tkinter widgets.

No GUI Thread Waiting with join()

The Start and close callbacks do not wait synchronously for a sleeping worker thread.

One-Minute Source Data Uses a 60-Second Refresh

The application avoids repeatedly requesting one-minute data every five seconds.

Existing SQLite Table Remains Compatible

The original columns remain:

id
stock_name
price
timestamp

This means an existing stock_data.db created by the older tutorial can still be opened by the revised viewer.

The Viewer Does Not Load Unlimited Rows

Only the latest 500 records are loaded by default.

Database Queries Use Parameters

The selected stock is never concatenated into the SQL statement.

Treeview Uses the Database Primary Key

The unique SQLite id becomes the Treeview iid, even though it does not have to be displayed as a visible column.

Next: Dedicated Real-Time Graph Project Top ↑

This page combines fetching, storage, graphing and database viewing. The next tutorial focuses more closely on the visualization side of the project.

Real-Time Stock Graph

Frequently Asked Questions Top ↑

Q1: Why save stock prices in SQLite?

SQLite gives the application persistent local storage so observations can be viewed again after the tracking application is closed.

Q2: Why does the worker thread not update the graph directly?

Tkinter and the embedded Matplotlib canvas belong to the GUI thread. The worker fetches data and sends its result through a Queue.

Q3: Why is each SQLite connection opened inside a function?

Short-lived local connections keep connection ownership clear and avoid sharing one SQLite connection across unrelated operations or threads.

Q4: Is the yfinance value guaranteed to be real-time?

No. It represents the latest available value returned by the source and may be delayed depending on market status and data availability.

Q5: Why does the graph keep only 60 points?

Limiting the in-memory list prevents the graph from growing indefinitely during a long tracking session. All stored observations can still remain in SQLite.

Q6: Can the viewer show stock data already stored by the older program?

Yes. The revised code keeps the original stock_prices table columns for compatibility.

Q7: Why does the viewer limit the result to 500 rows?

A Treeview does not need to load an unlimited database history at once. Limiting the first display keeps the interface responsive. Pagination or date filters can be added later.

Real-Time Data Tracker Real-Time Data Graph Treeview Pagination

More Projects using Tkinter

Python Tutorials Python Tkinter SQLite Treeview Matplotlib Threading

Subhendu Mohapatra

Author & Instructor at plus2net

I write and maintain practical tutorials on Python, PHP, SQL, JavaScript, HTML, jQuery, and web development at plus2net. The tutorials focus on clear explanations, working examples, and code that readers can test and adapt while learning.

About the author Watch on YouTube

Connect:

Subscribe to our YouTube Channel here

Tkinter SQLite Stock Tracker and Data Viewer

Part I: Track and Store Stock Data Top ↑

Libraries Used Top ↑

Create the SQLite Database Top ↑

Fetch the Latest Available Price Top ↑

Use a Worker Thread and Queue Top ↑

Save Stock Data in SQLite Top ↑

Update the Matplotlib Graph Top ↑

Start and Stop Tracking Top ↑

Complete Tracker and SQLite Storage Program Top ↑

Why Database and Graph Updates Stay on the Main Thread Top ↑

Part II: Display Stored Stock Data Top ↑

Populate the Stock Combobox from SQLite Top ↑

Display Stored Records in Treeview Top ↑

Complete SQLite Stock Data Viewer Top ↑

How This Version Improves the Original Project Top ↑

GUI Updates Stay on the Main Thread

No GUI Thread Waiting with join()

One-Minute Source Data Uses a 60-Second Refresh

Existing SQLite Table Remains Compatible

The Viewer Does Not Load Unlimited Rows

Database Queries Use Parameters

Treeview Uses the Database Primary Key

Next: Dedicated Real-Time Graph Project Top ↑

Frequently Asked Questions Top ↑

Subhendu Mohapatra