foreign-keys

I have a requirement where I need to find the referenced table name (Primary key table name) by a particular field in a table (Foreign key table) using this field name, table name (where this field resides) and the schema name (where the table and thereby the field resides) For example: Schema1.TableA Id (Integer, PK) Name varchar Schema2.TableB Id (integer, PK) A_Id (integer, FK referencing TableA.Id) Name varchar I need to pass A_Id , TableB and Schema2 to a function and get Schema1.TableA as result. I am using Postgres 8.3. Erwin Brandstetter If you don't need this to be portable to another

I am trying to figure out the fastest way to access data stored in a junction object. The example below is analagous to my problem, but with a different context, because the actual dataset I am dealing with is somewhat unintuitive in its relationships. We have 3 classes: User , Product , and Rating . User has a many-to-many relationship to Product with Rating as the junction/'through' class. The Rating object stores the answers to several questions which are integer ratings on a scale of 1-5 (Example questions: How is the quality of the Product , how is the value of the Product , how user

I'm receiving an error when I attempt to create two tables. There was a multivalued dependency, so I separated the tables and came up with this: CREATE TABLE NAME ( NameID Integer NOT NULL AUTO_INCREMENT, Name varChar(255) NOT NULL, CONSTRAINT NAME_PK PRIMARY KEY(NameID) ); CREATE TABLE PHONE ( NameID Integer NOT NULL, PhoneNumber varChar(15) NOT NULL, NumType varChar(5) NOT NULL, CONSTRAINT PHONE_FK FOREIGN KEY(NameID) REFERENCES NAME(NameID), CONSTRAINT PHONE_PK PRIMARY KEY(NameID) ); But when attempting to add values with this code: INSERT INTO NAME (NameID, Name) VALUES (default, 'John Doe

I went over a legacy database and found a couple of foreign keys that reference a column to itself. The referenced column is the primary key column. ALTER TABLE [SchemaName].[TableName] WITH CHECK ADD CONSTRAINT [FK_TableName_TableName] FOREIGN KEY([Id]) REFERENCES [SchemaName].[TableName] ([Id]) What is the meaning of it? ALTER TABLE [SchemaName].[TableName] WITH CHECK ADD CONSTRAINT [FK_TableName_TableName] FOREIGN KEY([Id]) REFERENCES [SchemaName].[TableName] ([Id]) This foreign key is completely redundant and pointless just delete it. It can never be violated as a row matches itself

It's accepted that searching a table on an int column is faster than on a string column (say varchar). However, if I have a Shirt table with a Color column, would it be more performant to create a Color table with the primary key on that table being the foreign key on the Shirt table? Would the join negate the performance advantage of having the value in the Color column on Shirt being an int instead of a string value such as "Green" when searching for green Shirts? Compared to the other operations being performed, it is unlikely that there is much performance difference between the two

This question already has an answer here: Sqlite / SQLAlchemy: how to enforce Foreign Keys? 7 answers I'm very new to SQLAlchemy and I'm trying to figure it out. Please have in mind the following test setup: class Nine(Base): __tablename__ = 'nine' __table_args__ = (sqlalchemy.sql.schema.UniqueConstraint('nine_b', name='uq_nine_b'), ) nine_a = sqlalchemy.Column(sqlalchemy.dialects.sqlite.INTEGER(), primary_key=True, autoincrement=False, nullable=False) nine_b = sqlalchemy.Column(sqlalchemy.String(20), nullable=False) class Seven(Base): __tablename__ = 'seven' __table_args__ = (sqlalchemy.sql

Often you join two tables following their foreign key, so that the row in the RHS table will always be found. Adding the join does not affect the number of rows affected by the query. For example create table a (x int not null primary key) create table b (x int not null primary key, y int not null) alter table a add foreign key (x) references b (x) Now, assuming you set up some data in these two tables, you can get a certain number of rows from a: select x from a Adding a join to b following the foreign key does not change this: select a.x from a join b on a.x = b.x However, that is not true