Hi, I have a very generic question. When data from...
# announcements
e
Hi, I have a very generic question. When data from a source is transferred to a target which guarantees are given that no data gets lost? This question relates to guaranteed message delivery in messaging systems like Kafka or Pulsar. Is the transfer of data "transaction safe"? Where are "tombstones" written that in the case of a failure the process of transferring data continues where it left off? The same question but now related to "exactly once". How is assured that data is not written twice?
👀 3
c
hi erik, great questions. i am going to split up my responses in the guarantees you gets for the two different types of sync modes that we are focused on right now. 1. FULL_REFRESH (means all the data is resent, all the previous data in the destination is overwritten) - In this case the preferred approach we take for of our data warehouses is to write all of the data into a temporary table in the warehouse. If there are any failures we abort and remove the temporary table. If there are no failures, then within a transaction (as supported by the warehouse) we replace the original table in the warehouse with the temporary one. In this case the guarantee is that you never get partial or missing data in your warehouse and you will find each record that in the destination exactly once.
2. INCREMENTAL (our first version of incremental is an append only approach -- so if a record is updated, we add a new copy of the record in the destination, but we do not do anything to delete the old one, the user is expected to handle de-duping using built-in functionality in the warehouse or dbt) - The approach for transferring data in this case is similar to previous case. We only send the new / updated data from the source to the destination. It is all written into a temporary table. If that is completely successful, within a transaction the temporary table is copied into the main table. In this case, by design, it is highly likely that you will end up with multiple copies of different versions of the same record in the destination. The contents of each delta should still have exactly once delivery and should never be missing records.
We will be adding support for doing the de-duping mentioned in my incremental explanation as well, but it will not be part of the first release of incremental.
e
Hi Charles. Thanks for explaining. To recap: 1. Incremental load does not capture deletes for now? 2. The target should be capable of handling transactions. So writing to for example S3 as a target might be cumbersome? 3. Or for example Kafka/Pulsar?
c
Great Questions!
1. That is correct. On the roadmap for subsequent release but not in our first release of incremental.
2. Not quite! All of the destinations we have written so far leverage transactions in the target to handle making operations atomic. When we write the S3 integration we should be handle writing data in atomic fashion. If you have specific features in mind for S3, lmk and we will take them into consideration. It will just be a little different implementation than say most relational databases which all have somewhat similar transaction abstractions.
3. I am not very familiar with Pulsar. For Kafka, I think we would be shooting for at least once delivery of every message, but I'm not sure we can do exactly once. So there might be duplicates.
e
Thanks again Charles. Sounds all very promising.
c
That is correct. On the roadmap for subsequent release but not in our first release of incremental.
Would you say this is most likely in the next few months? Sorry to hijack the thread, but my thoughts have pretty much been related to these questions 😅
👍 1
c
no worries at all. happy to talk about this here!
we are still figuring out the priority of it. we've definitely had a bunch of people mention it.
is this the main blocker for airbyte being useful to you? if so, would you be willing to share a bit more about your use case? the more info we have on why this blocks people from getting us from it, the higher we'll prioritize it.
i think this could potentially be something we start working on in january (but please don't hold me to that yet). and i think we have some clear ideas on how we would do it.
i'll make a node to post in this thread again or in general when we figure out when we are doing this.
c
so in short the use-case is just to sync data from a Postgresql db instance and Snowflake (data warehouse) most probably on a daily basis. I'm currently reviewing some options like airbyte, meltano etc the problem I foresee with the full table sync is the data transfer and the amount of data that needs to be transferred each day. looking at a data set of around ~250m+ rows (I haven't ran a full sync yet, just looking around for the most suitable options. so apologies for any confusion here!)
c
makes sense! thank you for sharing. incremental syncing is definitely going to be a better fit for that data size i would think. i'll keep you posted as we figure out when we are tackling deletions.
c
awesome, sounds good 👍 do you have a roadmap or release newsletter that can be subscribed to?
c
yes! you can subscribe to our newsletter here: https://airbyte.io/. we try not to be spammy, so at most sending an email once a week.
scroll down to the bottom.
our roadmap is in our docs https://docs.airbyte.io/roadmap. it's a little vague on this point right now, but will add more clarity on it there once we have it.
c
ah nice, done. suppose I'll keep an eye out there, but also will stick around in this Slack anyway
👍 1