planner | 🗓 the main codebar site | Application Framework library

This was a bug, and the issue should be resolved now.

I'm thinking each Reservation should know which Room is going to book, so it seems logical to have the Room inside. But that instance of Room already exists in the List of the Hotel.

What you tought is totally correct. You don't need to add a collection naivgational property of type Reservation (e.g. List) into your Room entity.

By adding a Room navigational property on Reservation entity, EF Core can handle the remainging things and by applying default convention it will consider that a reservation is for one room and a room can be related to multiple reservations even you don't created the reservation type into the Room entity.

There are two issues here. One is the actual behaviour of EXPLAIN, the other is a bug.

The first issue is that in Postgres, EXPLAIN costs are to the maximum extent possible intended to be realistic and be true to the actual, real-world cost and time required by an operation.

This is not the case with EXPLAIN in Redshift.

In Redshift, costs are arbitrary numbers. They have been selected by the developers, I think in an effort to rather crudely control the query planner.

I can see no advantages to this method, and no end of disadvantages, but there it is. (For example, you can't compare costs across queries - even the same basic query which you're only experimenting with to find the most efficient solution).

So, for example, in Redshift scanning a table has a cost of 1 per row.

Sorting a table has a cost of I think it was 1,000,000,000 (one billion), plus 1 per row - so scanning 1b records is considered cheaper than sorting one row, which is nuts. This is why the query planner goes wrong at times.

The second issue is that there is a bug in the costs presented by EXPLAIN with DS_DIST_BOTH. I believe it uses an uninitialized variable, and as a result has a cost which is about a million times more atoms than there are in the Universe.

I did try to tell Support. I tried for a while and then gave up. You have to understand the limiations of Redshift Support - they don't understand Redshift, and they don't really seem to be able to think very much for themselves. I came away from the discussion with the view that someone, at some point, had told them plan costs could become very large numbers, and from that point on it became impossible for them to comprehend that there could be a very large number and it could actually be wrong. This is by far not the only bug I have given up trying to get Support to comprehend.

Instead of the platform dependent install units like org.eclipse.core.filesystem.linux.x86_64, org.eclipse.core.filesystem.win32.x86, etc. you should add the install unit that contains the platform dependent units as children (with platform specific filters).

For your first , use the following three units instead of all the units you have (at least that's what works for me):

The data is stored inside javascript variable on that page. To parse the data (and create pandas dataframe form it) you can use this example:

TL;DR: After upgrade to Flink 1.12.4 the problem magically disappears.

Details

After upgrade from Flink 1.12.2 to Flink 1.12.3 the following code stopped to compile:

The dynamic model example you found is just that, an example: https://docs.jboss.org/hibernate/orm/5.4/userguide/html_single/Hibernate_User_Guide.html#dynamic-model

The Hibernate mapping is pretty flexible and is the predecessor of the annotation model, so you can map everything you can already do in Java. One problem is that the HBM mappings will go away at some point in favor of an extension to the JPA orm.xml mapping model. Every schema change would also require a rebuild of a SessionFactory with new models which also isn't that easy. So if you really want to do this, I would suggest you try to use the mapping model classes (PersistentClass, etc.) directly instead which is more future-proof.

I will advise against this approach anyway as that will not solve your underlying performance issue. If you want good performance, you should create dedicated types, tables and mappings for that purpose. If some parts are extensible, this can be modeled through a JSON or EAV model, but the performance of querying against that will usually still not be great. With a JSON approach you can at least create indexes for certain access patterns and don't need all these joins, but with EAV your only option to improve performance is to use pre-joined tables (Oracle table cluster) or a materialized view. Since incremental view maintenance is not a thing on any database other than Oracle and even that doesn't support outer joins for that, you are probably out of luck to get good performance with that model.

Doing many joins is certainly doable for a database, but there are limits. Most databases will stop their cost based optimization at a certain join amount and just apply rule based optimization which might not produce what you'd like.

As far as I can see, the way out of your performance issues is to use a JSON type which is supported on most modern databases in one way or another. You can map it a String if you want, it doesn't really matter. For accessing parts, you can add access functions to Hibernate. You could use a library like Blaze-Persistence which provides JSON access functions for various databases out of the box: https://persistence.blazebit.com/documentation/1.6/core/manual/en_US/#json_get

From there on, you just need to add indexes for certain filters if customers complain.

You can use the Planner API in Microsoft Graph to create and list tasks. Please see documentation here on adding the .Net SDK to your project, creating an authProvider instance and creating a task.

Please let me know if this helps, and if you have further questions.

Update: This is because the connector does not support mixed case table names. Mixed case column names are supported. There is a pull request to add support for mixed case table names: https://github.com/trinodb/trino/pull/7630