Redundant Joins being generated

Question

We currently have a performance issue which is caused by unneccessary
joins executed when navigating across relations. We have two tables call
them tableA and tableB with a relationship between them on columnA.
This is a legacy database (25 years old) and does not have any primary
key or foreign key constraints. tableA is mapped to ClassA and tableB is
mapped to ClassB. If we have an instance of ClassA and navigate to ClassB,
I would expect a simple SELECT query to be executed, but instead a join is
included as well. Each table has 200,000 or so rows, so instead of taking
10s of ms, the query is taking more than a second each time. I have
executed the query I would expect and it does take 10ms, and the hardware
we have is fairly meaty. If there something we have configured incorrectly,
or is the absence of primary and foreign keys causing the issue?
The SQL I would expect is:
select t1.columnA, t1.columnB, t1.columnC from tableB t1 where t1.columnA
= '0123456789'
Instead we get:
select t1.columnA, t1.columnB, t1.columnC from tableA t0 inner join tableB
on t0.columnA = t1.columnB where t0.colu
mnA = '0123456789'
I do not see the need for the join as the value of columnA is known,
making the join redundant.
Here are the details (abbreviated):
Java Classes:
public class ClassA {
private String columnA;
private ClassB classB;
public class ClassB {
private String columnA;
// some other fields
private String columnB;
private String columnC;
SQL Tables:
create table tableA (columnA char(10))
create table tableB (columnA char(10), columnB char(10), column char(10))
package.jdo: We have to lie to the kodo about foreign keys or nothing
works.
<class name="ClassA" objectid-class="ClassAId">
<field name="columnA" primary-key="true"/>
</class>
<class name="ClassB" objectid-class="ClassBId">
<field name="columnA" primary-key="true"/>
</class>
package.mapping:
<class name="ClassA">
<jdbc-class-map type="base" table="tableA"/>
<jdbc-version-ind type="state-image"/>
<field name="classB">
<jdbc-field-map type="one-one" column.columnA="columnA"/>
</field>
<field name="columnA">
<jdbc-field-map type="value" column="columnA"/>
</field>
</class>
<class name="ClassB">
<jdbc-class-map type="base" table="tableB"/>
<jdbc-version-ind type="state-image"/>
<field name="classB">
<jdbc-field-map type="one-one" column.columnA="columnA"/>
</field>
<field name="columnA">
<jdbc-field-map type="value" column="columnA"/>
</field>
<field name="columnB">
<jdbc-field-map type="value" column="columnB"/>
</field>
<field name="columnC">
<jdbc-field-map type="value" column="columnC"/>
</field>
</class>

Answer 1

OK,
My apologies it seems in the aim of simplifying the explanation of what is
occuring I missed some important pieces of information. It seems as though
the redundant joins are only occuring when do a mapping that contains a
constant value.
ie
<field name="classB">
<jdbc-field-map type="one-one" column.columnA="columnA"
column.columnB="XXXXXXXX" />
</field>
And looking at the Section 7.5 of the reference manual the SQL generated
has the redundant join also. Can someone explain why the join is necessary
in these circumstances. All the values of the join columns in tableB are
known, so why does tableA need to be referenced at all?