Im trying to figure out how to create a many to many relationship between my train table, and station table. I know I need a intermediate table, which I created I feel like I'm going in a loop thinking about what to do. I'll have a link to the data that explains the relationships between my tables and my schema below.
The only columns I'm looking at in this data are:
"GTFS_STOP_ID"(Id code for the Stop_Name),
"Stop_Name"(Name of train station), and
"Daytime Route"(which are the trains)
-One train can have many stations, and one station can also have many trains which is why in the "Daytime Routes" column you can see multiple trains. (For ex. N, W for the first row)
-How would I accurately depict relationships between these 3 columns in my csv, in my SQLITE database?
Link to data(apologies for the csv in advance as it's the only thing I was able to find online
cur.execute("""DROP TABLE IF EXISTS train""")
cur.execute(
""" CREATE TABLE train(
pk INTEGER PRIMARY KEY AUTOINCREMENT,
train_name VARCHAR
);""")
cur.execute("""DROP TABLE IF EXISTS station""")
cur.execute(
""" CREATE TABLE station(
pk INTEGER PRIMARY KEY AUTOINCREMENT,
stop_id VARCHAR,
station_name VARCHAR
);""")
cur.execute("""DROP TABLE IF EXISTS train_station""")
cur.execute(
""" CREATE TABLE train_station(
train_pk INTEGER,
station_pk INTEGER,
FOREIGN KEY (station_pk) REFERENCES station(pk)
FOREIGN KEY (train_pk) REFERENCES train(pk)
);"""
)
Related
I am using SQLite v3.31.1 and python 3.7.9.
How do I identify which tables a specific id value exists in? I think something like this exists in MYSQL as "INFORMATION_SCHEMA", but I have not found a SQLite alternative.
I have a table structure that follows what I believe is called "Class Table Inheritance". Basically, I have a product table that has attributes common to all products, plus tables that contain specific attributes to that class of products. The "Products" main table contains an id column that is a primary key, this is used as a foreign key in the child tables. So a specific item exists in both the product table and the child table, but nowhere else (other than some virtual tables for FTS).
My current solution is to get all tables names like
SELECT tbl_name
FROM sqlite_master
WHERE type='table'
and then loop over the tables using
SELECT 1
FROM child_table
WHERE id = value
but it seems like there should be a better way.
Thank you.
While the answer I originally posted will work, it is slow. You could add a hash map in python, but it will be slow while the hash map is rebuilt.
Instead, I am using triggers in my SQL setup to create a table with the relevant info. This is a bit more brittle, but much faster for large number of search results as the db is queried just once and the table is loaded when the database is initialized.
My example, -- there is a parent table called Products that has the id primary key.
CREATE TABLE IF NOT EXISTS ThermalFuse (
id INTEGER NOT NULL,
ratedTemperature INTEGER NOT NULL,
holdingTemperature INTEGER NOT NULL,
maximumTemperature INTEGER NOT NULL,
voltage INTEGER NOT NULL,
current INTEGER NOT NULL,
FOREIGN KEY (id) REFERENCES Product (id)
);
CREATE TABLE IF NOT EXISTS Table_Hash (
id INTEGER NOT NULL,
table_name TEXT NOT NULL,
FOREIGN KEY (id) REFERENCES Product (id)
);
CREATE TRIGGER ThermalFuse_ai AFTER INSERT ON ThermalFuse
BEGIN
INSERT INTO Table_Hash (id, table_name)
VALUES (new.id, 'ThermalFuse');
END;
I will create three tables. These tables belong to a category name. The 'Department' category linked to the 'Company' category and the 'Department_Unit' category linked to the 'Department' category. The user will first select Company, then select department, then department_unit. Do you think the query I wrote below is correct? Or do I need to write a different and better query?
thankyou very much.
create_table_company= '''CREATE TABLE company(
ID SERIAL PRIMARY KEY ,
NAME VARCHAR NOT NULL ,
); '''
create_table_department = '''CREATE TABLE department (
ID SERIAL PRIMARY KEY ,
NAME VARCHAR NOT NULL ,
company_id BIGINT,
FOREIGN KEY(company_id) REFERENCES COMPANY(id)); '''
create_table_department_unit = '''CREATE TABLE department_unit(
ID SERIAL PRIMARY KEY ,
NAME VARCHAR NOT NULL ,
department_id BIGINT,
FOREIGN KEY(department_id) REFERENCES DEPARTMENT(id)); '''
This data model looks fine.
Don't be worried that you have to join three tables whenever you need the company name that belongs to a department unit: databases are optimized to deal with such joins. In the case of an OLTP workload (you always select only a few rows from a table), this can be handled very efficiently with nested loop joins.
The only thing that is missing from your schema are two indexes:
CREATE INDEX ON department (company_id);
CREATE INDEX ON department_unit (department_id);
These indexes are needed
to make such nested loop joins efficient, for example if you are searching for all units that belong to a department
to make deletes or key updates efficient, which have to search the referencing table to verify that the foreign key constraint is still satisfied
I am experimenting with Python connections to a MySQL database using MySQL workbench and I have a peculiar question.
I have a program running which displays a list of albums in stock, and then the user can choose which albums to add, then when the user confirms the order is complete, there is script to write and commit these new rows to the database.
My issue is that: when the lines are written to the order_bridge table, the entryid is unique for every row, and there is no way for this primary key to reference the order table.
I was thinking to make a trigger which insert the total cost of the order into the orders table, grab the new auto_increment value from the created row, and then update the newly written rows in order_bridge to all have the same orderid, but I haven't been able wrap my head around the process.
Here is how the tables are designed:
create table albums
( albumid int,
albumname varchar(100),
artistname varchar(50),
price int,
quantity int,
primary key (albumid)
);
create table order_bridge (
entryid int auto_increment,
orderid int,
albumid int,
quantity int,
primary key (entryid),
foreign key (orderid) references orders (orderid),
foreign key (albumid) references albums (albumid)
);
create table orders
( orderid int auto_increment,
total decimal(5,2),
entrydate datetime default current_timestamp,
primary key(orderid)
);
I have solved this at least once by actually inserting every customer that is in the site cart into the orders table.
This does three things:
prevents order ids that complete from being consecutive (useless to some, useful for others),
provides a simple method for tracking cart abandonment statistics, and of course
allows you to have that unique order id when it comes time to record transactional data (like inserting selections into the order_bridge table).
Should you wish to only record the order row after the transaction finalizes, the order of operations should be:
insert order table info (including python calculation of total)
retrieve unique order table id
insert album rows
insert order bridge row
I have a table like this:
CREATE TABLE things
(id INTEGER PRIMARY KEY,
name TEXT,
status INTEGER);
There are these "things" which have a status that can be 1 or 0, this status is changed automatically by another part of my program.
I would like to store information about the time intervals when these things status is 0 or 1, what can I do?
I thought to create two tables:
CREATE TABLE status_from_0_to_1
(id INTEGER PRIMARY KEY,
datetime DATE,
things_id INTEGER,
FOREIGN KEY (id) REFERENCES things (id));
CREATE TABLE status_from_1_to_0
(id INTEGER PRIMARY KEY,
datetime DATE,
things_id INTEGER,
FOREIGN KEY (id) REFERENCES things (id));
But now I don't know how to write the query that check if the new status is different from the status in the table things and only in this case add a row in one of the two tables.
I don't know if this is the best approach, I also thought to create a single table (besides things) with two DATE fields but I think the query would be even more diffult.
I'm trying to make a relational database that connects 3 different tables. The main program database contains the vendors, that links to invoices from each vendor, then the invoices links to items purchased in that invoice.
tempcur.execute("""CREATE TABLE program (
vendorid INTEGER PRIMARY KEY,
vendor TEXT,
phone TEXT,
store INTEGER)""")
tempcur.execute("""CREATE TABLE dairystore (
invoice INTEGER REFERENCES program(vendorid),
date VARCHAR)""")
tempcur.execute("""CREATE TABLE invoices(
item INTEGER REFERENCES dairystore(invoice),
shipped VARCHAR,
description TEXT,
weight INTEGER,
price INTEGER,
amount INTEGER)""")
No, you have a mistake in dairystore table. It should be the following:
CREATE TABLE dairystore (
invoice INTEGER PRIMARY KEY,
vendor INTEGER REFERENCES program(vendorid),
date VARCHAR
)
You're trying to reference to dairystore.invoice from invoices table, so dairystore.invoice must be the id of record. In your code dairystore.invoice can't be the id of record because it is reference to program.vendorid and its values will be equal to ids of records in program table.