I am trying to find whether there is any support for identifier generation support we can use with R2DBC.
Similar to #GeneratedValue provided by hibernate for jdbc.
I know that spring-data-r2dbc doesn't support identifier generation yet.
Related
We are wondering what might be the best way to use micronaut-data to connect to BigQuery. BigQuery has a rather poor JDBC support and in addition it does not support transactions while micronaut-data enforces transactions.
Is there a way in the micronaut-data API to add an Annotation #BigQueryRepository and provide the annotation processor with information on how to generate the access to the database and how to generate queries?
Or would it be the correct way to just implement the CrudRepository interface and provide everything else on our own?
Or is micronaut-data just not the right tool to use here?
We are trying to get a feeling about if it would be a better way to extend micronaut-data or to implement it outside of micronaut-data.
Is there a way in the micronaut-data API to add an Annotation
#BigQueryRepository and provide the annotation processor with
information on how to generate the access to the database and how to
generate queries?
Quite likely, yes we could developer support like that.
Or would it be the correct way to just implement the CrudRepository
interface and provide everything else on our own?
You could write all of on on your own of course. I don't think Micronaut Data would be provided a whole lot at that point.
Or is micronaut-data just not the right tool to use here?
In its current state I don't think micronaut-data adds much for this scenario but that doesn't mean that it won't in the future.
You may take a look at our new Micronaut BigQuery library
https://agorapulse.github.io/micronaut-bigquery/
It allows you to run the basic SQL and it provides a mock implementation for testing.
This question has been asked back in 2012 , but I'm looking for new updates.
Are there any serialization formats that support tagged unions (aka sum types)? My requirements are that it has Java and .Net client libs, and it should be "reasonable mature". Performance is not a major concern.
Avro provides partial support, but does not allow nested unions (http://avro.apache.org/docs/1.7.6/spec.html#Unions). Cap'n Proto appears to have better support, but I'm not sure if it is production ready yet. Transit doesn't have direct support, but does provide an extension mechanism that might be able to support tagged unions.
Any other suggestions, or comments on the above choices?
Protocol Buffers version 2.6.0 added support for tagged unions in the form of the oneof declaration, but it looks like protobuf-net has not been updated recently so I'm guessing it doesn't support this yet.
Cap'n Proto is used in production in a lot of places (e.g. CloudFlare), but it's true that the C# and Java implementations are relatively new.
(Disclosure: I'm the author of Cap'n Proto, and also of most of Google's open source Protobuf code.)
I would like to use URNs in a project of mine. And I am hardly willing to apply my humble project for official IANA registration but would like to keep from violating standards if possible. That's why I'd like to know if there is a standard (or de-facto common practice at least) NID to be placed instead of private in the following example:
urn:private:mycompany:myproject:mycollection:myresource
According to rfc2611 you can define any NID you like so long as it starts with "X-". Such namespaces are considered experimental:
No provision is made for avoiding collision of experimental
NIDs; they are intended for use within internal or limited
experimental contexts.
As there is no registration, no registration maintenance
procedures are needed.
Judging from the information I have read about type providers so far, I wonder if they could be used to implement a nice ORM for F#.
I imagine that database rows could be represented by objects with correctly-typed properties, allowing type-safe read and write access to column values, with the type provider implementation automatically checking against the current database schema when compiling.
Is this a realistic and useful scenario?
Yes, that's an interesting use of type providers. One of the examples does just that, see http://msdn.microsoft.com/en-us/library/hh361033(v=vs.110).aspx
If I am correct then Type providers will be sort of "plugins" to F# compiler. They will plug the type information that F# compiler is not able to find while compiling the code. So basically while compiling the F# code the compiler will ask the type providers to fill in the types information which is not know to F# compiler. This also does mean that it is still about static typing i.e types are identified at compile time.
If the above understanding is correct, then in case of an ORM, you will need to implement a type provider for your relational scheme and this type provider will be used by F# compiler to compile your code to "fill-in" the types which represents your ORM mappings.
If you look at ORM, they are not just about mapping relational data to Objects, but also provide various operations like query, update etc on underlying relational data. In my opinion I don't think at this moment F# type providers are good for ORM, but I may be wrong :)
I'm evaluating a piece of software (uPortal), and it lists one of its features as "Pluggable APIs."
I know what an API is, but have not heard the pluggable term before. What does it mean for an API to be "pluggable"?
It means that you can replace the implementation. Like a provider model, like ODBC database drivers - you can plug in drivers for various databases, using the same API.