How do I load an entity from a relational DB when only part of the table schema is known in advance?

I have an entity mapped to a table. This table usually has some columns on top of the mapped properties. For example if the entity is defined as:

@Entity
class MyEntity {
  private String a;
}

Then the table has column a. In one schema it may also have columns b and c, in another d, e and f. I thought it would be simple to override EntityManager's load method to load all the properties defined in MyEntity and subsequently load all the others into a Map<String, Object>, but I can't find a way to do it.
Here's what I considered so far:

1. I found this SO question, which led to this post which maybe solves the issue but requires loading the mapping on startup, which doesn't solve my problem since I'm constantly switching between schemas and therefore would have to reload the mapping over and over.
2. Overriding RelationalMappingContext also assumes a constant schema.
3. There should be a way to supply EntityManager as a bean but I can't figure out how and I'm not sure if that wouldn't run into the same issues as 1 & 2.
4. I can do something complicated with bytecode manipulation but this would require having an Entity per schema, which is too complicated.
5. So I'm forced to consider overriding all methods in CrudRepository and providing my own implementation. That would be very hacky and unwieldy.

Any other ideas?

you have two Option in this situation

1. Use a NoSQL database: If you need to add columns dynamically and frequently, you might consider using a NoSQL database that supports dynamic schemas. NoSQL databases like MongoDB is designed to handle dynamic data and allow you to store documents or key-value pairs without enforcing a fixed schema.

2. Use a JSON or XML column: Some databases like PostgreSQL or MySQL support JSON or XML columns that can store semi-structured data. You can store your dynamic data as a JSON or XML document in a single column and query it using SQL or NoSQL-like queries.

For example, if you are using PostgreSQL, you can define a JSON column in your my_table table like this:

ALTER TABLE my_table ADD COLUMN dynamic_data jsonb;

You can then insert JSON documents into the dynamic_data column and query them using PostgreSQL's JSON functions.

Alternatively, you can use Hibernate's @Type annotation to map a JSON or XML column to a Java object. For example:

@Entity
@Table(name = "my_table")
public class MyEntity {

   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;

   @Type(type = "jsonb")
   @Column(columnDefinition = "jsonb")
   private Map<String, Object> dynamicData;

}

In the end I went with Spring AOP. The cutpoint intercepts every repository method decorated with a custom annotation. When that happens the cutpoint method issues another query of SELECT * (in the case of reads) and populates the entity with the extra properties.