benefit | Utility CSS-in-JS library | Frontend Utils library

One of the contributors to Debezium seems to affirm this is a product bug https://gitter.im/debezium/user?at=60b8e96778e1d6477d7f40b5. I have created an issue https://issues.redhat.com/browse/DBZ-3597.

Edit:

A PR was published and approved to fix the issue. The fix is in the current 1.6 beta snapshot build.

There is a possible workaround. The names of indices are the key to the problem. It seems they are processed in alphabetical order. Only the first one is taken into consideration so if you can rename your indices to have the one with keys first then you should get unblocked.

I'm the morphia dev so there's some bias here but i'll try to be fair. when i first started building the pojo support in to the driver (i used to work for mongodb) my goal was to build as close to an ODM as possible in the driver so that morphia, such as it was, would only need to be a thin veneer on the driver. Some of my plans never came to fruition as I left the company mid-effort. That said, it came pretty close.

I know of several projects that are happily using the pojo codecs. If they fit your needs, then I would suggest to just go with that. For my own perspective, I think morphia offers a fair bit that the driver doesn't (to my knowledge.) Morphia supports annotation driven index and document validation definitions, and collection caps, e.g. It's a bit more powerful and forgiving in mapping. e.g., morphia can map non-String keyed Maps as fields and I don't think the driver supports. Morphia supports lifecycle events but the driver does not and last I checked it seemed like Morphia's generics support had a slight edge. (Granted that edge is probably an extreme edge case that most won't run in to. It's been a while so the details are fuzzy.)

There are a few other features that Morphia has that the driver doesn't (transparent reference support, e.g.) and some features I have planned that the driver will never support (build-time generated codecs to eliminate most/all reflection at runtime, e.g.).

So do we still need Morphia? It depends on what you want to do. I plan on working on Morphia until no one needs it, though. :)

I believe links is listed next to api because so far it's the only thing inside of the api directory if you were to create more sub-apis it'd be listed underneath it as you'd expect. It's just a vscode UI.

Now, why does it sit underneath api and not to next to it you may ask. It's because api directory is intended to group all of your models' logic so sooner or later you'd end up creating a directory to hold them all.

This is mostly an option question but ... probably not? The core Service system does most of the same thing. But if you're specifically using Eureka's service metadata system then maybe?

This is how I've been using Dapper. Works great:

1. Make your Dapper method async.
2. Make the method or event that CALLS your method an async Task as well, so you can await the Task.
3. To return a list, do return (await blah blah blah).ToList();
4. Use the Async versions of all SQL calls.

Something seems a little off with your foreach loop. Would you mind explaining what you're trying to achieve with it? It seems like your first query should return all the models you need.

Example:

I’m not an expert in exposures but I hope my answer can give you some directions.

Q1 - As far I’m aware you just need to specify the direct tables that it depends on. dbt would automatically handle the downstream references. It’s important to make sure that all your models and sources are properly configured and that you are using the ref and source function when referencing them. This is how dbt track the nodes and dependencies to generate the DAG for the documentation.

Q2 - One of the benefits of having exposure is that it improves your documentation and helps the team to understand how the data flow through the reporting/dashboard. Let’s say the business users asked for new requirements or changes need to be done in the dashboard, the analyst can easily go to the exposure and see all the dependencies, and the code that the dashboard is using and from there can make a fast decision and move the requirements to the ETL team or whatever. Another example could be related to refresh. Imagine you are working in a serie of objects from the same context or tag, for instance, project, and you need to refresh only the objects from the project scope that are being used in a specific dashboard. To achieve that, you can run the dbt command only for that exposure.

Q3 - The purpose of those commands is to run and test only the models and references of a particular exposure. You can think about this as a different way for tagging reporting objects or whatever were declared in the exposure. It can be really useful for some cases.

Hope that helps, thanks!

If your projects often change together, consider merging them into a mono-repo and take advantage of multi module builds which will result in a directory structure similar to

What you are looking for is an enumeration type – designed specifically for the purpose you outline. Although you can use a plain, 'C-style' enum, a more modern, C++ approach is to use a so-called "scoped enum"; see: Why is enum class preferred over plain enum?

Here's a possible implementation of your code using such a enum class definition:

The answer linked by you explains why it is technically impossible to support lateinit for primitive types. So even if there are benefits of having them, then... well, see above, it is technically impossible.

You can use a property delegate for a very similar effect: