\n>> wrote:\n>>\n>> the preparing of content before execution is interesting idea, that can\n>>> be used more. The almost queries and plans are not too big, so when the\n>>> size of content is not too big - less than 1MB, then can be used one DSM\n>>> for all backends.\n>>>\n>>\n>>\n>>> When size of content is bigger than limit, then DSM will be allocated\n>>> specially for this content. The pointer to DSM and offset can be stored in\n>>> requested process slot. The reading and writing to requested slot should be\n>>> protected by spinlock, but it should block only two related processes for\n>>> short time (copy memory).\n>>>\n>>\n>> Sorry, I don't think this will fly.\n>>\n>> The whole idea is that a backend publishes the plan of a query just\n>> before running it and it doesn't care which other backend(s) might be\n>> reading it, how many times and in which order. The only required locking\n>> (implicit) is contained in the code for dsm_attach/detach().\n>>\n>\n> I didn't propose too different solution. There is only one difference -\n> sharing DSM for smaller data. It is similar to using usual shared memory.\n>\n\nDoes this mean implementing some sort of allocator on top of the shared\nmemory segment? If so, how are you going to prevent fragmentation?\n\n--\nAlex\n\nOn Mon, Sep 28, 2015 at 12:05 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-28 12:01 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Sun, Sep 27, 2015 at 8:05 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:the preparing of content before execution is interesting idea, that can be used more. The almost queries and plans are not too big, so when the size of content is not too big - less than 1MB, then can be used one DSM for all backends. When size of content is bigger than limit, then DSM will be allocated specially for this content. The pointer to DSM and offset can be stored in requested process slot. The reading and writing to requested slot should be protected by spinlock, but it should block only two related processes for short time (copy memory).Sorry, I don't think this will fly.The whole idea is that a backend publishes the plan of a query just before running it and it doesn't care which other backend(s) might be reading it, how many times and in which order. The only required locking (implicit) is contained in the code for dsm_attach/detach().I didn't propose too different solution. There is only one difference - sharing DSM for smaller data. It is similar to using usual shared memory.Does this mean implementing some sort of allocator on top of the shared memory segment? If so, how are you going to prevent fragmentation?--Alex","msg_date":"Mon, 28 Sep 2015 12:37:42 +0200","msg_from":"\"Shulgin, Oleksandr\" <oleksandr.shulgin@zalando.de>","msg_from_op":true,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"On Fri, Sep 25, 2015 at 7:13 PM, Shulgin, Oleksandr <\noleksandr.shulgin@zalando.de> wrote:\n\n>\n> Some implementation details:\n>\n> For every backend that might be running (MaxBackends) we reserve a\n> dsm_handle slot in the addins shared memory. When the new option is turned\n> on, the ExecutorRun hook will produce a plan in whatever format is\n> specified by the auto_explain.log_format, allocate a DSM segment, copy the\n> plan into the segment and finally store the DSM handle into its own slot.\n> No locking is required around this because every backend writes to its slot\n> exclusively, no other backend can be writing into it concurrently. In the\n> ExecutorFinish hook we invalidate the backend's slot by setting the handle\n> to 0 and deallocate the DSM segment.\n>\n\nAnd this patch adds back the use of table of contents on the DSM.\nBenefits: magic number validation; communication of the actual plan size.\n\n--\nAlex\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 28 Sep 2015 16:24:33 +0200","msg_from":"\"Shulgin, Oleksandr\" <oleksandr.shulgin@zalando.de>","msg_from_op":true,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"2015-09-28 12:37 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\n:\n\n> On Mon, Sep 28, 2015 at 12:05 PM, Pavel Stehule <pavel.stehule@gmail.com>\n> wrote:\n>\n>>\n>> 2015-09-28 12:01 GMT+02:00 Shulgin, Oleksandr <\n>> oleksandr.shulgin@zalando.de>:\n>>\n>>> On Sun, Sep 27, 2015 at 8:05 AM, Pavel Stehule <pavel.stehule@gmail.com>\n>>> wrote:\n>>>\n>>> the preparing of content before execution is interesting idea, that can\n>>>> be used more. The almost queries and plans are not too big, so when the\n>>>> size of content is not too big - less than 1MB, then can be used one DSM\n>>>> for all backends.\n>>>>\n>>>\n>>>\n>>>> When size of content is bigger than limit, then DSM will be allocated\n>>>> specially for this content. The pointer to DSM and offset can be stored in\n>>>> requested process slot. The reading and writing to requested slot should be\n>>>> protected by spinlock, but it should block only two related processes for\n>>>> short time (copy memory).\n>>>>\n>>>\n>>> Sorry, I don't think this will fly.\n>>>\n>>> The whole idea is that a backend publishes the plan of a query just\n>>> before running it and it doesn't care which other backend(s) might be\n>>> reading it, how many times and in which order. The only required locking\n>>> (implicit) is contained in the code for dsm_attach/detach().\n>>>\n>>\n>> I didn't propose too different solution. There is only one difference -\n>> sharing DSM for smaller data. It is similar to using usual shared memory.\n>>\n>\n> Does this mean implementing some sort of allocator on top of the shared\n> memory segment? If so, how are you going to prevent fragmentation?\n>\n\nyes, simple memory allocator is necessary in this case. But it should be\nreally simple - you can allocate only fixed size blocks - 10KB, 100KB and\n1MB from separate buffers. So the fragmentation is not possible.\n\nRegards\n\nPavel\n\n\n>\n> --\n> Alex\n>\n>\n\n2015-09-28 12:37 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Mon, Sep 28, 2015 at 12:05 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-28 12:01 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Sun, Sep 27, 2015 at 8:05 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:the preparing of content before execution is interesting idea, that can be used more. The almost queries and plans are not too big, so when the size of content is not too big - less than 1MB, then can be used one DSM for all backends. When size of content is bigger than limit, then DSM will be allocated specially for this content. The pointer to DSM and offset can be stored in requested process slot. The reading and writing to requested slot should be protected by spinlock, but it should block only two related processes for short time (copy memory).Sorry, I don't think this will fly.The whole idea is that a backend publishes the plan of a query just before running it and it doesn't care which other backend(s) might be reading it, how many times and in which order. The only required locking (implicit) is contained in the code for dsm_attach/detach().I didn't propose too different solution. There is only one difference - sharing DSM for smaller data. It is similar to using usual shared memory.Does this mean implementing some sort of allocator on top of the shared memory segment? If so, how are you going to prevent fragmentation?yes, simple memory allocator is necessary in this case. But it should be really simple - you can allocate only fixed size blocks - 10KB, 100KB and 1MB from separate buffers. So the fragmentation is not possible.RegardsPavel --Alex","msg_date":"Mon, 28 Sep 2015 19:09:54 +0200","msg_from":"Pavel Stehule <pavel.stehule@gmail.com>","msg_from_op":false,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"On Mon, Sep 28, 2015 at 7:09 PM, Pavel Stehule <pavel.stehule@gmail.com>\nwrote:\n\n>\n> 2015-09-28 12:37 GMT+02:00 Shulgin, Oleksandr <\n> oleksandr.shulgin@zalando.de>:\n>\n>>\n>>> I didn't propose too different solution. There is only one difference -\n>>> sharing DSM for smaller data. It is similar to using usual shared memory.\n>>>\n>>\n>> Does this mean implementing some sort of allocator on top of the shared\n>> memory segment? If so, how are you going to prevent fragmentation?\n>>\n>\n> yes, simple memory allocator is necessary in this case. But it should be\n> really simple - you can allocate only fixed size blocks - 10KB, 100KB and\n> 1MB from separate buffers. So the fragmentation is not possible.\n>\n\nMaybe we're talking about completely different ideas, but I don't see how\nfixing the block helps to fight fragmentation, in particular. Can you\nsketch a simple example? E.g. 400 backends share the common segment and\nall of them want to publish a plan of ~1kb, for example. Now what?\n\n--\nAlex\n\nOn Mon, Sep 28, 2015 at 7:09 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-28 12:37 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:I didn't propose too different solution. There is only one difference - sharing DSM for smaller data. It is similar to using usual shared memory.Does this mean implementing some sort of allocator on top of the shared memory segment? If so, how are you going to prevent fragmentation?yes, simple memory allocator is necessary in this case. But it should be really simple - you can allocate only fixed size blocks - 10KB, 100KB and 1MB from separate buffers. So the fragmentation is not possible.Maybe we're talking about completely different ideas, but I don't see how fixing the block helps to fight fragmentation, in particular. Can you sketch a simple example? E.g. 400 backends share the common segment and all of them want to publish a plan of ~1kb, for example. Now what?--Alex","msg_date":"Mon, 28 Sep 2015 19:13:55 +0200","msg_from":"\"Shulgin, Oleksandr\" <oleksandr.shulgin@zalando.de>","msg_from_op":true,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"2015-09-28 19:13 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\n:\n\n> On Mon, Sep 28, 2015 at 7:09 PM, Pavel Stehule <pavel.stehule@gmail.com>\n> wrote:\n>\n>>\n>> 2015-09-28 12:37 GMT+02:00 Shulgin, Oleksandr <\n>> oleksandr.shulgin@zalando.de>:\n>>\n>>>\n>>>> I didn't propose too different solution. There is only one difference -\n>>>> sharing DSM for smaller data. It is similar to using usual shared memory.\n>>>>\n>>>\n>>> Does this mean implementing some sort of allocator on top of the shared\n>>> memory segment? If so, how are you going to prevent fragmentation?\n>>>\n>>\n>> yes, simple memory allocator is necessary in this case. But it should be\n>> really simple - you can allocate only fixed size blocks - 10KB, 100KB and\n>> 1MB from separate buffers. So the fragmentation is not possible.\n>>\n>\n> Maybe we're talking about completely different ideas, but I don't see how\n> fixing the block helps to fight fragmentation, in particular. Can you\n> sketch a simple example? E.g. 400 backends share the common segment and\n> all of them want to publish a plan of ~1kb, for example. Now what?\n>\n\n\nProbably only few backends will be data requesters and few backends will be\nrequested for data. The size of shared data will be typically less than\n10KB, with few exceptions 100KB, and few exceptions 10MB. So for 400\nbackends you need 400*10KB+100*100KB+20*1MB = 34MB. You can have three\nindependent buffers for this sizes. If some process require 5KB then you\nreturns 10KB (it is good enough) from first buffer. This simple mechanism\ncan coverage 90% of usage. for other 10% you can create new DSM. Because\nyou are working with fixed size blocks and you don't divide the size of\nblock, then the fragmentation isn't possible. This model allow very fast\nallocation, very fast deallocation.\n\nIt is not terribly effective, but 34MB is better than 400 DSM or than 400MB\n(max size for any backend).\n\nOur super long queries are terribly long > 1MB, but we use a few clients\n(less than 2x CPU cores)\n\nRegards\n\nPavel\n\n\n>\n> --\n> Alex\n>\n>\n\n2015-09-28 19:13 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Mon, Sep 28, 2015 at 7:09 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-28 12:37 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:I didn't propose too different solution. There is only one difference - sharing DSM for smaller data. It is similar to using usual shared memory.Does this mean implementing some sort of allocator on top of the shared memory segment? If so, how are you going to prevent fragmentation?yes, simple memory allocator is necessary in this case. But it should be really simple - you can allocate only fixed size blocks - 10KB, 100KB and 1MB from separate buffers. So the fragmentation is not possible.Maybe we're talking about completely different ideas, but I don't see how fixing the block helps to fight fragmentation, in particular. Can you sketch a simple example? E.g. 400 backends share the common segment and all of them want to publish a plan of ~1kb, for example. Now what?Probably only few backends will be data requesters and few backends will be requested for data. The size of shared data will be typically less than 10KB, with few exceptions 100KB, and few exceptions 10MB. So for 400 backends you need 400*10KB+100*100KB+20*1MB = 34MB. You can have three independent buffers for this sizes. If some process require 5KB then you returns 10KB (it is good enough) from first buffer. This simple mechanism can coverage 90% of usage. for other 10% you can create new DSM. Because you are working with fixed size blocks and you don't divide the size of block, then the fragmentation isn't possible. This model allow very fast allocation, very fast deallocation. It is not terribly effective, but 34MB is better than 400 DSM or than 400MB (max size for any backend).Our super long queries are terribly long > 1MB, but we use a few clients (less than 2x CPU cores)RegardsPavel --Alex","msg_date":"Mon, 28 Sep 2015 20:06:35 +0200","msg_from":"Pavel Stehule <pavel.stehule@gmail.com>","msg_from_op":false,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"On 9/18/15 5:05 AM, Shulgin, Oleksandr wrote:\n>\n> It should not be true - the data sender create DSM and fills it.\n> Then set caller slot and send signal to caller. Caller can free DSM\n> any time, because data sender send newer touch it.\n>\n>\n> But the requester can timeout on waiting for reply and exit before it\n> sees the reply DSM. Actually, I now don't even think a backend can free\n> the DSM it has not created. First it will need to attach it,\n> effectively increasing the refcount, and upon detach it will only\n> decrease the refcount, but not actually release the segment...\n>\n> So this has to be the responsibility of the reply sending backend in the\n> end: to create and release the DSM *at some point*.\n\nWhat's wrong with just releasing it at the end of the statement? When \nthe statement is done there's no point to reading it asynchronously anymore.\n-- \nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\nExperts in Analytics, Data Architecture and PostgreSQL\nData in Trouble? Get it in Treble! http://BlueTreble.com\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 28 Sep 2015 17:28:12 -0500","msg_from":"Jim Nasby <Jim.Nasby@BlueTreble.com>","msg_from_op":false,"msg_subject":"Re: On-demand running query plans using auto_explain and\n signals"},{"msg_contents":"On Tue, Sep 29, 2015 at 12:28 AM, Jim Nasby <Jim.Nasby@bluetreble.com>\nwrote:\n\n> On 9/18/15 5:05 AM, Shulgin, Oleksandr wrote:\n>\n>>\n>> So this has to be the responsibility of the reply sending backend in the\n>> end: to create and release the DSM *at some point*.\n>>\n>\n> What's wrong with just releasing it at the end of the statement? When the\n> statement is done there's no point to reading it asynchronously anymore.\n\n\nThat was only one of the problems in signals-based design, and it has other\nmore significant problems. The current approach does exactly that:\nallocate the segment before running the plan, release at the end of the\nstatement.\n\n--\nAlex\n\nOn Tue, Sep 29, 2015 at 12:28 AM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:On 9/18/15 5:05 AM, Shulgin, Oleksandr wrote:\n\nSo this has to be the responsibility of the reply sending backend in the\nend: to create and release the DSM *at some point*.\n\n\nWhat's wrong with just releasing it at the end of the statement? When the statement is done there's no point to reading it asynchronously anymore.That was only one of the problems in signals-based design, and it has other more significant problems. The current approach does exactly that: allocate the segment before running the plan, release at the end of the statement.--Alex","msg_date":"Tue, 29 Sep 2015 12:52:11 +0200","msg_from":"\"Shulgin, Oleksandr\" <oleksandr.shulgin@zalando.de>","msg_from_op":true,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"On 2015-09-25 19:13:13 +0200, Shulgin, Oleksandr wrote:\n> the auto_explain contrib module. I now propose the most simple thing\n> possible in my opinion: a new GUC option for auto_explain. It will make\n> every backend, in which the module is loaded via *_preload_libraries\n> mechanism or using CREATE EXTENSION/LOAD commands, to actively publish the\n> plans of queries in dynamic shared memory as long as\n> auto_explain.publish_plans is turned on.\n\nWait. You're proposing that every query does this unconditionally? For\nevery single query? That sounds prohibitively expensive to me.\n\nGreetings,\n\nAndres Freund\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 29 Sep 2015 12:57:25 +0200","msg_from":"Andres Freund <andres@anarazel.de>","msg_from_op":false,"msg_subject":"Re: On-demand running query plans using auto_explain and\n signals"},{"msg_contents":"On Tue, Sep 29, 2015 at 12:57 PM, Andres Freund <andres@anarazel.de> wrote:\n\n> On 2015-09-25 19:13:13 +0200, Shulgin, Oleksandr wrote:\n> > the auto_explain contrib module. I now propose the most simple thing\n> > possible in my opinion: a new GUC option for auto_explain. It will make\n> > every backend, in which the module is loaded via *_preload_libraries\n> > mechanism or using CREATE EXTENSION/LOAD commands, to actively publish\n> the\n> > plans of queries in dynamic shared memory as long as\n> > auto_explain.publish_plans is turned on.\n>\n> Wait. You're proposing that every query does this unconditionally? For\n> every single query? That sounds prohibitively expensive to me.\n>\n\nOnly if the extension is loaded AND the option is turned on. Likely you\ndon't want to do this for an OLTP database, but for other types of load it\nmight make sense. Also, I think it should be possible to toggle this on a\nper-process basis.\n\nFinally, we can put in a cost threshold, so the plans only get published if\nthey have total_cost >= publish_plan_cost_threshod.\n\nAlso, do you mean expensive in terms of CPU or the dynamic shared memory?\n\n--\nAlex\n\nOn Tue, Sep 29, 2015 at 12:57 PM, Andres Freund <andres@anarazel.de> wrote:On 2015-09-25 19:13:13 +0200, Shulgin, Oleksandr wrote:\n> the auto_explain contrib module. I now propose the most simple thing\n> possible in my opinion: a new GUC option for auto_explain. It will make\n> every backend, in which the module is loaded via *_preload_libraries\n> mechanism or using CREATE EXTENSION/LOAD commands, to actively publish the\n> plans of queries in dynamic shared memory as long as\n> auto_explain.publish_plans is turned on.\n\nWait. You're proposing that every query does this unconditionally? For\nevery single query? That sounds prohibitively expensive to me.Only if the extension is loaded AND the option is turned on. Likely you don't want to do this for an OLTP database, but for other types of load it might make sense. Also, I think it should be possible to toggle this on a per-process basis.Finally, we can put in a cost threshold, so the plans only get published if they have total_cost >= publish_plan_cost_threshod.Also, do you mean expensive in terms of CPU or the dynamic shared memory?--Alex","msg_date":"Tue, 29 Sep 2015 13:12:35 +0200","msg_from":"\"Shulgin, Oleksandr\" <oleksandr.shulgin@zalando.de>","msg_from_op":true,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"On 25 September 2015 at 12:13, Shulgin, Oleksandr <\noleksandr.shulgin@zalando.de> wrote:\n\n\n> I now believe that use of ProcessInterrupts() in the recently proposed\n> design as well as manipulation of proc latch due to use of shared memory\n> queue are major blockers.\n>\n> In order to simplify things up, I've taken a step back and looked again at\n> the auto_explain contrib module. I now propose the most simple thing\n> possible in my opinion: a new GUC option for auto_explain. It will make\n> every backend, in which the module is loaded via *_preload_libraries\n> mechanism or using CREATE EXTENSION/LOAD commands, to actively publish the\n> plans of queries in dynamic shared memory as long as\n> auto_explain.publish_plans is turned on.\n>\n> The greatest part for me, is that this approach doesn't require handling\n> of signals and is isolated in an external module, so it can be readily used\n> with the current server versions, no need to wait for >= 9.6.\n>\n\nThis is a major change of direction, so the thread title no longer applies\nat all.\n\nThe requirement is to be able to see the output of EXPLAIN ANALYZE for a\nrunning process. Ideally, we would dump the diagnostic output for any\nprocess that runs longer than a specific timeout, so we can decide whether\nto kill it, or just save that for later diagnostics.\n\nI'm interested in helping the original goal happen. Dumping an EXPLAIN,\nwithout ANALYZE info, is not at all interesting since it has no value for\nimmediate action or post-facto diagnosis, sorry to say - making it happen\nfor every backend just makes it even less useful.\n\n-- \nSimon Riggs http://www.2ndQuadrant.com/\n<http://www.2ndquadrant.com/>\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\nOn 25 September 2015 at 12:13, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote: I now believe that use of ProcessInterrupts() in the recently proposed design as well as manipulation of proc latch due to use of shared memory queue are major blockers.In order to simplify things up, I've taken a step back and looked again at the auto_explain contrib module. I now propose the most simple thing possible in my opinion: a new GUC option for auto_explain. It will make every backend, in which the module is loaded via *_preload_libraries mechanism or using CREATE EXTENSION/LOAD commands, to actively publish the plans of queries in dynamic shared memory as long as auto_explain.publish_plans is turned on.The greatest part for me, is that this approach doesn't require handling of signals and is isolated in an external module, so it can be readily used with the current server versions, no need to wait for >= 9.6.This is a major change of direction, so the thread title no longer applies at all.The requirement is to be able to see the output of EXPLAIN ANALYZE for a running process. Ideally, we would dump the diagnostic output for any process that runs longer than a specific timeout, so we can decide whether to kill it, or just save that for later diagnostics.I'm interested in helping the original goal happen. Dumping an EXPLAIN, without ANALYZE info, is not at all interesting since it has no value for immediate action or post-facto diagnosis, sorry to say - making it happen for every backend just makes it even less useful.-- Simon Riggs http://www.2ndQuadrant.com/PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services","msg_date":"Tue, 29 Sep 2015 12:01:43 -0500","msg_from":"Simon Riggs <simon@2ndQuadrant.com>","msg_from_op":false,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"On Tue, Sep 29, 2015 at 7:01 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\n\n> On 25 September 2015 at 12:13, Shulgin, Oleksandr <\n> oleksandr.shulgin@zalando.de> wrote:\n>\n>\n>> I now believe that use of ProcessInterrupts() in the recently proposed\n>> design as well as manipulation of proc latch due to use of shared memory\n>> queue are major blockers.\n>>\n>> In order to simplify things up, I've taken a step back and looked again\n>> at the auto_explain contrib module. I now propose the most simple thing\n>> possible in my opinion: a new GUC option for auto_explain. It will make\n>> every backend, in which the module is loaded via *_preload_libraries\n>> mechanism or using CREATE EXTENSION/LOAD commands, to actively publish the\n>> plans of queries in dynamic shared memory as long as\n>> auto_explain.publish_plans is turned on.\n>>\n>> The greatest part for me, is that this approach doesn't require handling\n>> of signals and is isolated in an external module, so it can be readily used\n>> with the current server versions, no need to wait for >= 9.6.\n>>\n>\n> This is a major change of direction, so the thread title no longer applies\n> at all.\n>\n> The requirement is to be able to see the output of EXPLAIN ANALYZE for a\n> running process. Ideally, we would dump the diagnostic output for any\n> process that runs longer than a specific timeout, so we can decide whether\n> to kill it, or just save that for later diagnostics.\n>\n> I'm interested in helping the original goal happen. Dumping an EXPLAIN,\n> without ANALYZE info, is not at all interesting since it has no value for\n> immediate action or post-facto diagnosis, sorry to say - making it happen\n> for every backend just makes it even less useful.\n>\n\nThis is not a change of the direction, but rather of the approach. Hitting\na process with a signal and hoping it will produce a meaningful response in\nall circumstances without disrupting its current task was way too naive.\nI'd really want to make this work with ANALYZE, just not as the first\nstep. I believe this approach can be extended to include instrumentation\nsupport (obviously we will not be able to contain this in the auto_explain\nmodule).\n\n--\nAlex\n\nOn Tue, Sep 29, 2015 at 7:01 PM, Simon Riggs <simon@2ndquadrant.com> wrote:On 25 September 2015 at 12:13, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote: I now believe that use of ProcessInterrupts() in the recently proposed design as well as manipulation of proc latch due to use of shared memory queue are major blockers.In order to simplify things up, I've taken a step back and looked again at the auto_explain contrib module. I now propose the most simple thing possible in my opinion: a new GUC option for auto_explain. It will make every backend, in which the module is loaded via *_preload_libraries mechanism or using CREATE EXTENSION/LOAD commands, to actively publish the plans of queries in dynamic shared memory as long as auto_explain.publish_plans is turned on.The greatest part for me, is that this approach doesn't require handling of signals and is isolated in an external module, so it can be readily used with the current server versions, no need to wait for >= 9.6.This is a major change of direction, so the thread title no longer applies at all.The requirement is to be able to see the output of EXPLAIN ANALYZE for a running process. Ideally, we would dump the diagnostic output for any process that runs longer than a specific timeout, so we can decide whether to kill it, or just save that for later diagnostics.I'm interested in helping the original goal happen. Dumping an EXPLAIN, without ANALYZE info, is not at all interesting since it has no value for immediate action or post-facto diagnosis, sorry to say - making it happen for every backend just makes it even less useful.This is not a change of the direction, but rather of the approach. Hitting a process with a signal and hoping it will produce a meaningful response in all circumstances without disrupting its current task was way too naive. I'd really want to make this work with ANALYZE, just not as the first step. I believe this approach can be extended to include instrumentation support (obviously we will not be able to contain this in the auto_explain module).--Alex","msg_date":"Tue, 29 Sep 2015 19:52:46 +0200","msg_from":"\"Shulgin, Oleksandr\" <oleksandr.shulgin@zalando.de>","msg_from_op":true,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"On 29 September 2015 at 12:52, Shulgin, Oleksandr <\noleksandr.shulgin@zalando.de> wrote:\n\n\n> Hitting a process with a signal and hoping it will produce a meaningful\n> response in all circumstances without disrupting its current task was way\n> too naive.\n>\n\nHmm, I would have to disagree, sorry. For me the problem was dynamically\nallocating everything at the time the signal is received and getting into\nproblems when that caused errors.\n\n* INIT - Allocate N areas of memory for use by queries, which can be\nexpanded/contracted as needed. Keep a freelist of structures.\n* OBSERVER - When requested, gain exclusive access to a diagnostic area,\nthen allocate the designated process to that area, then send a signal\n* QUERY - When signal received dump an EXPLAIN ANALYZE to the allocated\ndiagnostic area, (set flag to show complete, set latch on observer)\n* OBSERVER - process data in diagnostic area and then release area for use\nby next observation\n\nIf the EXPLAIN ANALYZE doesn't fit into the diagnostic chunk, LOG it as a\nproblem and copy data only up to the size defined. Any other ERRORs that\nare caused by this process cause it to fail normally.\n\nThat allows the observer to be another backend, or it allows the query\nprocess to perform self-observation based upon a timeout (e.g. >1 hour) or\na row limit (e.g. when an optimizer estimate is seen to be badly wrong).\n\n-- \nSimon Riggs http://www.2ndQuadrant.com/\n<http://www.2ndquadrant.com/>\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\nOn 29 September 2015 at 12:52, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote: Hitting a process with a signal and hoping it will produce a meaningful response in all circumstances without disrupting its current task was way too naive. Hmm, I would have to disagree, sorry. For me the problem was dynamically allocating everything at the time the signal is received and getting into problems when that caused errors.* INIT - Allocate N areas of memory for use by queries, which can be expanded/contracted as needed. Keep a freelist of structures.* OBSERVER - When requested, gain exclusive access to a diagnostic area, then allocate the designated process to that area, then send a signal* QUERY - When signal received dump an EXPLAIN ANALYZE to the allocated diagnostic area, (set flag to show complete, set latch on observer)* OBSERVER - process data in diagnostic area and then release area for use by next observationIf the EXPLAIN ANALYZE doesn't fit into the diagnostic chunk, LOG it as a problem and copy data only up to the size defined. Any other ERRORs that are caused by this process cause it to fail normally.That allows the observer to be another backend, or it allows the query process to perform self-observation based upon a timeout (e.g. >1 hour) or a row limit (e.g. when an optimizer estimate is seen to be badly wrong).-- Simon Riggs http://www.2ndQuadrant.com/PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services","msg_date":"Tue, 29 Sep 2015 13:34:12 -0500","msg_from":"Simon Riggs <simon@2ndQuadrant.com>","msg_from_op":false,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"On Tue, Sep 29, 2015 at 8:34 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\n\n> On 29 September 2015 at 12:52, Shulgin, Oleksandr <\n> oleksandr.shulgin@zalando.de> wrote:\n>\n>\n>> Hitting a process with a signal and hoping it will produce a meaningful\n>> response in all circumstances without disrupting its current task was way\n>> too naive.\n>>\n>\n> Hmm, I would have to disagree, sorry. For me the problem was dynamically\n> allocating everything at the time the signal is received and getting into\n> problems when that caused errors.\n>\n\nWhat I mean is that we need to move the actual EXPLAIN run out of\nProcessInterrupts(). It can be still fine to trigger the communication\nwith a signal.\n\n* INIT - Allocate N areas of memory for use by queries, which can be\n> expanded/contracted as needed. Keep a freelist of structures.\n> * OBSERVER - When requested, gain exclusive access to a diagnostic area,\n> then allocate the designated process to that area, then send a signal\n> * QUERY - When signal received dump an EXPLAIN ANALYZE to the allocated\n> diagnostic area, (set flag to show complete, set latch on observer)\n> * OBSERVER - process data in diagnostic area and then release area for use\n> by next observation\n>\n> If the EXPLAIN ANALYZE doesn't fit into the diagnostic chunk, LOG it as a\n> problem and copy data only up to the size defined. Any other ERRORs that\n> are caused by this process cause it to fail normally.\n>\n\nDo you envision problems if we do this with a newly allocated DSM every\ntime instead of pre-allocated area? This will have to revert the workflow,\nbecause only the QUERY knows the required segment size:\n\nOBSERVER - sends a signal and waits for its proc latch to be set\nQUERY - when signal is received allocates a DSM just big enough to fit the\nEXPLAIN plan, then locates the OBSERVER(s) and sets its latch (or their\nlatches)\n\nThe EXPLAIN plan should already be produced somewhere in the executor, to\navoid calling into explain.c from ProcessInterrupts().\n\nThat allows the observer to be another backend, or it allows the query\n> process to perform self-observation based upon a timeout (e.g. >1 hour) or\n> a row limit (e.g. when an optimizer estimate is seen to be badly wrong).\n>\n\nDo you think there is one single best place in the executor code where such\na check could be added? I have very little idea about that.\n\n--\nAlex\n\nOn Tue, Sep 29, 2015 at 8:34 PM, Simon Riggs <simon@2ndquadrant.com> wrote:On 29 September 2015 at 12:52, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote: Hitting a process with a signal and hoping it will produce a meaningful response in all circumstances without disrupting its current task was way too naive. Hmm, I would have to disagree, sorry. For me the problem was dynamically allocating everything at the time the signal is received and getting into problems when that caused errors.What I mean is that we need to move the actual EXPLAIN run out of ProcessInterrupts(). It can be still fine to trigger the communication with a signal.* INIT - Allocate N areas of memory for use by queries, which can be expanded/contracted as needed. Keep a freelist of structures.* OBSERVER - When requested, gain exclusive access to a diagnostic area, then allocate the designated process to that area, then send a signal* QUERY - When signal received dump an EXPLAIN ANALYZE to the allocated diagnostic area, (set flag to show complete, set latch on observer)* OBSERVER - process data in diagnostic area and then release area for use by next observationIf the EXPLAIN ANALYZE doesn't fit into the diagnostic chunk, LOG it as a problem and copy data only up to the size defined. Any other ERRORs that are caused by this process cause it to fail normally.Do you envision problems if we do this with a newly allocated DSM every time instead of pre-allocated area? This will have to revert the workflow, because only the QUERY knows the required segment size:OBSERVER - sends a signal and waits for its proc latch to be setQUERY - when signal is received allocates a DSM just big enough to fit the EXPLAIN plan, then locates the OBSERVER(s) and sets its latch (or their latches)The EXPLAIN plan should already be produced somewhere in the executor, to avoid calling into explain.c from ProcessInterrupts().That allows the observer to be another backend, or it allows the query process to perform self-observation based upon a timeout (e.g. >1 hour) or a row limit (e.g. when an optimizer estimate is seen to be badly wrong).Do you think there is one single best place in the executor code where such a check could be added? I have very little idea about that.--Alex","msg_date":"Tue, 29 Sep 2015 21:52:10 +0200","msg_from":"\"Shulgin, Oleksandr\" <oleksandr.shulgin@zalando.de>","msg_from_op":true,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"On 29 September 2015 at 20:52, Shulgin, Oleksandr <\noleksandr.shulgin@zalando.de> wrote:\n\n> On Tue, Sep 29, 2015 at 8:34 PM, Simon Riggs <simon@2ndquadrant.com>\n> wrote:\n>\n>> On 29 September 2015 at 12:52, Shulgin, Oleksandr <\n>> oleksandr.shulgin@zalando.de> wrote:\n>>\n>>\n>>> Hitting a process with a signal and hoping it will produce a meaningful\n>>> response in all circumstances without disrupting its current task was way\n>>> too naive.\n>>>\n>>\n>> Hmm, I would have to disagree, sorry. For me the problem was dynamically\n>> allocating everything at the time the signal is received and getting into\n>> problems when that caused errors.\n>>\n>\n> What I mean is that we need to move the actual EXPLAIN run out of\n> ProcessInterrupts(). It can be still fine to trigger the communication\n> with a signal.\n>\n\nGood\n\n\n> * INIT - Allocate N areas of memory for use by queries, which can be\n>> expanded/contracted as needed. Keep a freelist of structures.\n>> * OBSERVER - When requested, gain exclusive access to a diagnostic area,\n>> then allocate the designated process to that area, then send a signal\n>> * QUERY - When signal received dump an EXPLAIN ANALYZE to the allocated\n>> diagnostic area, (set flag to show complete, set latch on observer)\n>> * OBSERVER - process data in diagnostic area and then release area for\n>> use by next observation\n>>\n>> If the EXPLAIN ANALYZE doesn't fit into the diagnostic chunk, LOG it as a\n>> problem and copy data only up to the size defined. Any other ERRORs that\n>> are caused by this process cause it to fail normally.\n>>\n>\n> Do you envision problems if we do this with a newly allocated DSM every\n> time instead of pre-allocated area? This will have to revert the workflow,\n> because only the QUERY knows the required segment size:\n>\n\nThat's too fiddly; we need to keep it simple by using just fixed sizes.\n\n\n> OBSERVER - sends a signal and waits for its proc latch to be set\n> QUERY - when signal is received allocates a DSM just big enough to fit the\n> EXPLAIN plan, then locates the OBSERVER(s) and sets its latch (or their\n> latches)\n>\n> The EXPLAIN plan should already be produced somewhere in the executor, to\n> avoid calling into explain.c from ProcessInterrupts().\n>\n> That allows the observer to be another backend, or it allows the query\n>> process to perform self-observation based upon a timeout (e.g. >1 hour) or\n>> a row limit (e.g. when an optimizer estimate is seen to be badly wrong).\n>>\n>\n> Do you think there is one single best place in the executor code where\n> such a check could be added? I have very little idea about that.\n>\n\n Fairly simple.\n\nMain problem is knowing how to handle nested calls to the executor.\n\nI'll look at the patch.\n\n-- \nSimon Riggs http://www.2ndQuadrant.com/\n<http://www.2ndquadrant.com/>\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\nOn 29 September 2015 at 20:52, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote:On Tue, Sep 29, 2015 at 8:34 PM, Simon Riggs <simon@2ndquadrant.com> wrote:On 29 September 2015 at 12:52, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote: Hitting a process with a signal and hoping it will produce a meaningful response in all circumstances without disrupting its current task was way too naive. Hmm, I would have to disagree, sorry. For me the problem was dynamically allocating everything at the time the signal is received and getting into problems when that caused errors.What I mean is that we need to move the actual EXPLAIN run out of ProcessInterrupts(). It can be still fine to trigger the communication with a signal.Good * INIT - Allocate N areas of memory for use by queries, which can be expanded/contracted as needed. Keep a freelist of structures.* OBSERVER - When requested, gain exclusive access to a diagnostic area, then allocate the designated process to that area, then send a signal* QUERY - When signal received dump an EXPLAIN ANALYZE to the allocated diagnostic area, (set flag to show complete, set latch on observer)* OBSERVER - process data in diagnostic area and then release area for use by next observationIf the EXPLAIN ANALYZE doesn't fit into the diagnostic chunk, LOG it as a problem and copy data only up to the size defined. Any other ERRORs that are caused by this process cause it to fail normally.Do you envision problems if we do this with a newly allocated DSM every time instead of pre-allocated area? This will have to revert the workflow, because only the QUERY knows the required segment size:That's too fiddly; we need to keep it simple by using just fixed sizes. OBSERVER - sends a signal and waits for its proc latch to be setQUERY - when signal is received allocates a DSM just big enough to fit the EXPLAIN plan, then locates the OBSERVER(s) and sets its latch (or their latches)The EXPLAIN plan should already be produced somewhere in the executor, to avoid calling into explain.c from ProcessInterrupts().That allows the observer to be another backend, or it allows the query process to perform self-observation based upon a timeout (e.g. >1 hour) or a row limit (e.g. when an optimizer estimate is seen to be badly wrong).Do you think there is one single best place in the executor code where such a check could be added? I have very little idea about that. Fairly simple.Main problem is knowing how to handle nested calls to the executor.I'll look at the patch.-- Simon Riggs http://www.2ndQuadrant.com/PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services","msg_date":"Tue, 29 Sep 2015 21:59:20 +0100","msg_from":"Simon Riggs <simon@2ndQuadrant.com>","msg_from_op":false,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"On Tue, Sep 29, 2015 at 1:52 PM, Shulgin, Oleksandr\n<oleksandr.shulgin@zalando.de> wrote:\n> This is not a change of the direction, but rather of the approach. Hitting\n> a process with a signal and hoping it will produce a meaningful response in\n> all circumstances without disrupting its current task was way too naive.\n\nI think that's exactly right. It's not safe to do much anything from\na signal handler, and while ProcessInterrupts() is a very\nsubstantially safer, the set of things that can be safely done there\nis still awfully restricted. You have to cope with the fact that the\nfunction you just interrupted may be doing anything at all, and if you\nchange anything before returning, you may knock over the apple cart.\nJust as bad, the state you inherit may not be very sane: we call\nProcessInterrupts() from LOTS of places and there is absolutely no\nguarantee that every one of those places has the data structures that\nyou need to run EXPLAIN ANALYZE in a sane state.\n\nI haven't looked at the new patch specifically so I don't have an\nopinion on that at this time.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 2 Oct 2015 16:25:45 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"On Tue, Sep 29, 2015 at 7:52 PM, Shulgin, Oleksandr <\noleksandr.shulgin@zalando.de> wrote:\n\n>\n> This is not a change of the direction, but rather of the approach.\n> Hitting a process with a signal and hoping it will produce a meaningful\n> response in all circumstances without disrupting its current task was way\n> too naive. I'd really want to make this work with ANALYZE, just not as the\n> first step. I believe this approach can be extended to include\n> instrumentation support (obviously we will not be able to contain this in\n> the auto_explain module).\n>\n\nI was thinking about this and what seems to be the biggest problem is when\nto actually turn the feature on. It seems unlikely that someone will want\nto enable it unconditionally. Enabling per-backend also doesn't seem to be\na good approach because you don't know if the next query you'd like to look\nat is going to run in this exact backend.\n\nWhat might be actually usable is poking pg_stat_statements for queryid to\ndecide if we need to do explain (and possibly analyze). We could make it\nso that the explain is produced for any query that is known to run longer\nthan certain configurable threshold on average (or we can provide for\nenabling this explicitly per entry in pg_stat_statements). Then the\ninterested client can go and do pg_explain_backend() on the pid.\n\nIf we would also track the plan total costs, we could do some predictions\nso that if the same query comes along and is planned with total cost\nexceeding the recorded average the configurable amount of percent, then we\nenable explain.\n\nDoes this make sense to you? Does this make a good argument for merging\npg_stat_statements and auto_explain into core?\n\n--\nAlex\n\nOn Tue, Sep 29, 2015 at 7:52 PM, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote:This is not a change of the direction, but rather of the approach. Hitting a process with a signal and hoping it will produce a meaningful response in all circumstances without disrupting its current task was way too naive. I'd really want to make this work with ANALYZE, just not as the first step. I believe this approach can be extended to include instrumentation support (obviously we will not be able to contain this in the auto_explain module).I was thinking about this and what seems to be the biggest problem is when to actually turn the feature on. It seems unlikely that someone will want to enable it unconditionally. Enabling per-backend also doesn't seem to be a good approach because you don't know if the next query you'd like to look at is going to run in this exact backend.What might be actually usable is poking pg_stat_statements for queryid to decide if we need to do explain (and possibly analyze). We could make it so that the explain is produced for any query that is known to run longer than certain configurable threshold on average (or we can provide for enabling this explicitly per entry in pg_stat_statements). Then the interested client can go and do pg_explain_backend() on the pid.If we would also track the plan total costs, we could do some predictions so that if the same query comes along and is planned with total cost exceeding the recorded average the configurable amount of percent, then we enable explain.Does this make sense to you? Does this make a good argument for merging pg_stat_statements and auto_explain into core?--Alex","msg_date":"Thu, 15 Oct 2015 11:16:01 +0200","msg_from":"\"Shulgin, Oleksandr\" <oleksandr.shulgin@zalando.de>","msg_from_op":true,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"\"Shulgin, Oleksandr\" <oleksandr.shulgin@zalando.de> writes:\n> I was thinking about this and what seems to be the biggest problem is when\n> to actually turn the feature on. It seems unlikely that someone will want\n> to enable it unconditionally. Enabling per-backend also doesn't seem to be\n> a good approach because you don't know if the next query you'd like to look\n> at is going to run in this exact backend.\n\nCheck.\n\n> What might be actually usable is poking pg_stat_statements for queryid to\n> decide if we need to do explain (and possibly analyze).\n\nHm, interesting thought.\n\n> Does this make sense to you? Does this make a good argument for merging\n> pg_stat_statements and auto_explain into core?\n\nI'd say more that it's a good argument for moving this feature out to\none of those extensions, or perhaps building a third extension that\ndepends on both of those. TBH, none of this stuff smells to me like\nsomething that ought to be in core.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 15 Oct 2015 09:42:47 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"2015-10-15 15:42 GMT+02:00 Tom Lane <tgl@sss.pgh.pa.us>:\n\n> \"Shulgin, Oleksandr\" <oleksandr.shulgin@zalando.de> writes:\n> > I was thinking about this and what seems to be the biggest problem is\n> when\n> > to actually turn the feature on. It seems unlikely that someone will\n> want\n> > to enable it unconditionally. Enabling per-backend also doesn't seem to\n> be\n> > a good approach because you don't know if the next query you'd like to\n> look\n> > at is going to run in this exact backend.\n>\n> Check.\n>\n> > What might be actually usable is poking pg_stat_statements for queryid to\n> > decide if we need to do explain (and possibly analyze).\n>\n> Hm, interesting thought.\n>\n> > Does this make sense to you? Does this make a good argument for merging\n> > pg_stat_statements and auto_explain into core?\n>\n> I'd say more that it's a good argument for moving this feature out to\n> one of those extensions, or perhaps building a third extension that\n> depends on both of those. TBH, none of this stuff smells to me like\n> something that ought to be in core.\n>\n\nThere are few features, that I would to see in core:\n\n1. possibility to get full SQL string\n2. possibility to get state string\n\nWe can speak how to do it well.\n\nRegards\n\nPavel\n\n\n\n>\n> regards, tom lane\n>\n\n2015-10-15 15:42 GMT+02:00 Tom Lane <tgl@sss.pgh.pa.us>:\"Shulgin, Oleksandr\" <oleksandr.shulgin@zalando.de> writes:\n> I was thinking about this and what seems to be the biggest problem is when\n> to actually turn the feature on. It seems unlikely that someone will want\n> to enable it unconditionally. Enabling per-backend also doesn't seem to be\n> a good approach because you don't know if the next query you'd like to look\n> at is going to run in this exact backend.\n\nCheck.\n\n> What might be actually usable is poking pg_stat_statements for queryid to\n> decide if we need to do explain (and possibly analyze).\n\nHm, interesting thought.\n\n> Does this make sense to you? Does this make a good argument for merging\n> pg_stat_statements and auto_explain into core?\n\nI'd say more that it's a good argument for moving this feature out to\none of those extensions, or perhaps building a third extension that\ndepends on both of those. TBH, none of this stuff smells to me like\nsomething that ought to be in core.There are few features, that I would to see in core:1. possibility to get full SQL string2. possibility to get state stringWe can speak how to do it well.RegardsPavel \n\n regards, tom lane","msg_date":"Thu, 15 Oct 2015 16:04:08 +0200","msg_from":"Pavel Stehule <pavel.stehule@gmail.com>","msg_from_op":false,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"Hello,\n\nOn 15/10/2015 16:04, Pavel Stehule wrote:\n> \n> \n> 2015-10-15 15:42 GMT+02:00 Tom Lane <tgl@sss.pgh.pa.us\n> <mailto:tgl@sss.pgh.pa.us>>:\n> \n> \"Shulgin, Oleksandr\" <oleksandr.shulgin@zalando.de\n> <mailto:oleksandr.shulgin@zalando.de>> writes:\n> > I was thinking about this and what seems to be the biggest problem is when\n> > to actually turn the feature on. It seems unlikely that someone will want\n> > to enable it unconditionally. Enabling per-backend also doesn't seem to be\n> > a good approach because you don't know if the next query you'd like to look\n> > at is going to run in this exact backend.\n> \n> Check.\n> \n> > What might be actually usable is poking pg_stat_statements for queryid to\n> > decide if we need to do explain (and possibly analyze).\n> \n> Hm, interesting thought.\n> \n> > Does this make sense to you? Does this make a good argument for merging\n> > pg_stat_statements and auto_explain into core?\n> \n> I'd say more that it's a good argument for moving this feature out to\n> one of those extensions, or perhaps building a third extension that\n> depends on both of those. TBH, none of this stuff smells to me like\n> something that ought to be in core.\n> \n> \n> There are few features, that I would to see in core:\n> \n> 1. possibility to get full SQL string\n> 2. possibility to get state string\n> \n> We can speak how to do it well.\n> \n\nI registered as reviewer on this, but after reading the whole thread for\nthe second time, it's still not clear to me if the last two submitted\npatches (0001-Add-auto_explain.publish_plans.patch and\n0002-Add-SHM-table-of-contents-to-the-explain-DSM.patch) are still\nneeded reviews, since multiple refactoring ideas and objections have\nbeen raised since.\n\n\nRegards.\n\n-- \nJulien Rouhaud\nhttp://dalibo.com - http://dalibo.org\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 30 Nov 2015 22:27:24 +0100","msg_from":"Julien Rouhaud <julien.rouhaud@dalibo.com>","msg_from_op":false,"msg_subject":"Re: On-demand running query plans using auto_explain and\n signals"},{"msg_contents":"On 30 November 2015 at 22:27, Julien Rouhaud <julien.rouhaud@dalibo.com>\nwrote:\n\n\n> I registered as reviewer on this, but after reading the whole thread for\n> the second time, it's still not clear to me if the last two submitted\n> patches (0001-Add-auto_explain.publish_plans.patch and\n> 0002-Add-SHM-table-of-contents-to-the-explain-DSM.patch) are still\n> needed reviews, since multiple refactoring ideas and objections have\n> been raised since.\n>\n\nI looked into it more deeply and decided partial EXPLAINs aren't very\nuseful yet.\n\nI've got some thoughts around that which I'll publish when I have more\ntime. I suggest this is a good idea, just needs some serious\ncommitter-love, so we should bounce this for now.\n\n-- \nSimon Riggs http://www.2ndQuadrant.com/\n<http://www.2ndquadrant.com/>\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\nOn 30 November 2015 at 22:27, Julien Rouhaud <julien.rouhaud@dalibo.com> wrote: I registered as reviewer on this, but after reading the whole thread for\nthe second time, it's still not clear to me if the last two submitted\npatches (0001-Add-auto_explain.publish_plans.patch and\n0002-Add-SHM-table-of-contents-to-the-explain-DSM.patch) are still\nneeded reviews, since multiple refactoring ideas and objections have\nbeen raised since.I looked into it more deeply and decided partial EXPLAINs aren't very useful yet.I've got some thoughts around that which I'll publish when I have more time. I suggest this is a good idea, just needs some serious committer-love, so we should bounce this for now.-- Simon Riggs http://www.2ndQuadrant.com/PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services","msg_date":"Tue, 1 Dec 2015 00:04:27 +0100","msg_from":"Simon Riggs <simon@2ndQuadrant.com>","msg_from_op":false,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"On Tue, Dec 1, 2015 at 12:04 AM, Simon Riggs <simon@2ndquadrant.com> wrote:\n\n> On 30 November 2015 at 22:27, Julien Rouhaud <julien.rouhaud@dalibo.com>\n> wrote:\n>\n>\n>> I registered as reviewer on this, but after reading the whole thread for\n>> the second time, it's still not clear to me if the last two submitted\n>> patches (0001-Add-auto_explain.publish_plans.patch and\n>> 0002-Add-SHM-table-of-contents-to-the-explain-DSM.patch) are still\n>> needed reviews, since multiple refactoring ideas and objections have\n>> been raised since.\n>>\n>\n> I looked into it more deeply and decided partial EXPLAINs aren't very\n> useful yet.\n>\n> I've got some thoughts around that which I'll publish when I have more\n> time. I suggest this is a good idea, just needs some serious\n> committer-love, so we should bounce this for now.\n>\n\nI have the plans to make something from this on top of pg_stat_statements\nand auto_explain, as I've mentioned last time. The next iteration will be\nbased on the two latest patches above, so it still makes sense to review\nthem.\n\nAs for EXPLAIN ANALYZE support, it will require changes to core, but this\ncan be done separately.\n\n--\nAlex\n\nOn Tue, Dec 1, 2015 at 12:04 AM, Simon Riggs <simon@2ndquadrant.com> wrote:On 30 November 2015 at 22:27, Julien Rouhaud <julien.rouhaud@dalibo.com> wrote: I registered as reviewer on this, but after reading the whole thread for\nthe second time, it's still not clear to me if the last two submitted\npatches (0001-Add-auto_explain.publish_plans.patch and\n0002-Add-SHM-table-of-contents-to-the-explain-DSM.patch) are still\nneeded reviews, since multiple refactoring ideas and objections have\nbeen raised since.I looked into it more deeply and decided partial EXPLAINs aren't very useful yet.I've got some thoughts around that which I'll publish when I have more time. I suggest this is a good idea, just needs some serious committer-love, so we should bounce this for now.I have the plans to make something from this on top of pg_stat_statements and auto_explain, as I've mentioned last time. The next iteration will be based on the two latest patches above, so it still makes sense to review them.As for EXPLAIN ANALYZE support, it will require changes to core, but this can be done separately.--Alex","msg_date":"Tue, 1 Dec 2015 10:34:32 +0100","msg_from":"\"Shulgin, Oleksandr\" <oleksandr.shulgin@zalando.de>","msg_from_op":true,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"Hi,\n\nOn 12/01/2015 10:34 AM, Shulgin, Oleksandr wrote:\n>\n> I have the plans to make something from this on top of\n> pg_stat_statements and auto_explain, as I've mentioned last time. The\n> next iteration will be based on the two latest patches above, so it\n> still makes sense to review them.\n>\n> As for EXPLAIN ANALYZE support, it will require changes to core, but\n> this can be done separately.\n\nI'm re-reading the thread, and I have to admit I'm utterly confused what \nis the current plan, what features it's supposed to provide and whether \nit will solve the use case I'm most interested in. Oleksandr, could you \nplease post a summary explaining that?\n\nMy use case for this functionality is debugging of long-running queries, \nparticularly getting EXPLAIN ANALYZE for them. In such cases I either \ncan't run the EXPLAIN ANALYZE manually because it will either run \nforever (just like the query) and may not be the same (e.g. due to \nrecent ANALYZE). So we need to extract the data from the process \nexecuting the query.\n\nI'm not essentially opposed to doing this in an extension (better an \nextension than nothing), but I don't quite see how you could to do that \nfrom pg_stat_statements or auto_explain. AFAIK both extensions merely \nuse hooks before/after the executor, and therefore can't do anything in \nbetween (while the query is actually running).\n\nPerhaps you don't intend to solve this particular use case? Which use \ncases are you aiming to solve, then? Could you explain?\n\n\nMaybe all we need to do is add another hook somewhere in the executor, \nand push the explain analyze into pg_stat_statements once in a while, \nentirely eliminating the need for inter-process communication (signals, \nqueues, ...).\n\nI'm pretty sure we don't need this for \"short\" queries, because in those \ncases we have other means to get the explain analyze (e.g. running the \nquery again or auto_explain). So I can imagine having a rather high \nthreshold (say, 60 seconds or even more), and we'd only push the explain \nanalyze after crossing it. And then we'd only update it once in a while \n- say, again every 60 seconds.\n\nOf course, this might be configurable by two GUCs:\n\n pg_stat_statements.explain_analyze_threshold = 60 # -1 is \"off\"\n pg_stat_statements.explain_analyze_refresh = 60\n\nFWIW I'd still prefer having \"EXPLAIN ANALYZE\" in core, but better this \nthan nothing.\n\n\nregards\n\n--\nTomas Vondra http://www.2ndQuadrant.com\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 16 Dec 2015 20:39:58 +0100","msg_from":"Tomas Vondra <tomas.vondra@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: On-demand running query plans using auto_explain and\n signals"},{"msg_contents":"On Wed, Dec 16, 2015 at 8:39 PM, Tomas Vondra <tomas.vondra@2ndquadrant.com>\nwrote:\n\n> Hi,\n>\n> On 12/01/2015 10:34 AM, Shulgin, Oleksandr wrote:\n>\n>>\n>> I have the plans to make something from this on top of\n>> pg_stat_statements and auto_explain, as I've mentioned last time. The\n>> next iteration will be based on the two latest patches above, so it\n>> still makes sense to review them.\n>>\n>> As for EXPLAIN ANALYZE support, it will require changes to core, but\n>> this can be done separately.\n>>\n>\n> I'm re-reading the thread, and I have to admit I'm utterly confused what\n> is the current plan, what features it's supposed to provide and whether it\n> will solve the use case I'm most interested in. Oleksandr, could you please\n> post a summary explaining that?\n>\n> My use case for this functionality is debugging of long-running queries,\n> particularly getting EXPLAIN ANALYZE for them. In such cases I either can't\n> run the EXPLAIN ANALYZE manually because it will either run forever (just\n> like the query) and may not be the same (e.g. due to recent ANALYZE). So we\n> need to extract the data from the process executing the query.\n>\n> I'm not essentially opposed to doing this in an extension (better an\n> extension than nothing), but I don't quite see how you could to do that\n> from pg_stat_statements or auto_explain. AFAIK both extensions merely use\n> hooks before/after the executor, and therefore can't do anything in between\n> (while the query is actually running).\n>\n> Perhaps you don't intend to solve this particular use case? Which use\n> cases are you aiming to solve, then? Could you explain?\n>\n\nHi Tomas.\n\nThanks for your interest in this patch!\n\nMy motivation is the same as your use case: having a long-running query, be\nable to look inside this exact query run by this exact backend.\n\nI admit the evolution of ideas in this patch can be very confusing: we were\ntrying a number of different approaches, w/o thinking deeply on the\nimplications, just to have a proof of concept.\n\nMaybe all we need to do is add another hook somewhere in the executor, and\n> push the explain analyze into pg_stat_statements once in a while, entirely\n> eliminating the need for inter-process communication (signals, queues, ...).\n>\n> I'm pretty sure we don't need this for \"short\" queries, because in those\n> cases we have other means to get the explain analyze (e.g. running the\n> query again or auto_explain). So I can imagine having a rather high\n> threshold (say, 60 seconds or even more), and we'd only push the explain\n> analyze after crossing it. And then we'd only update it once in a while -\n> say, again every 60 seconds.\n>\n> Of course, this might be configurable by two GUCs:\n>\n> pg_stat_statements.explain_analyze_threshold = 60 # -1 is \"off\"\n> pg_stat_statements.explain_analyze_refresh = 60\n>\n> FWIW I'd still prefer having \"EXPLAIN ANALYZE\" in core, but better this\n> than nothing.\n>\n\nYes, this is how pg_stat_statements idea comes into play: even if we\nimplement support for online EXPLAIN ANALYZE, enabling it for every query\nis an overkill, but if you don't enable it from the query start, there is\nno way to enable it later on as the query has already progressed. So in\norder to know for which queries it makes sense to enable this feature, we\nneed to know what is the query's expected run time, thus pg_stat_statements\nseems like a natural place to obtain this information and/or trigger the\nbehavior.\n\nI'm also all for simplification of the underlying communication mechanism:\nshared memory queues are neat, but not necessarily the best way to handle\nit. As for the use of signals: I believe this was a red herring, it will\nmake the code much less fragile if the progressing backend itself will\npublish intermediary EXPLAIN ANALYZE reports for other backends to read.\n\nThe EXPLAIN (w/o ANALYZE) we can do completely as an extension: no core\nsupport required. To enable ANALYZE it will require a little hacking\naround Instrumentation methods: otherwise the Explain functions just crash\nwhen run in the middle of the query.\n\nHope that makes it clear.\n\n--\nAlex\n\nOn Wed, Dec 16, 2015 at 8:39 PM, Tomas Vondra <tomas.vondra@2ndquadrant.com> wrote:Hi,\n\nOn 12/01/2015 10:34 AM, Shulgin, Oleksandr wrote:\n\n\nI have the plans to make something from this on top of\npg_stat_statements and auto_explain, as I've mentioned last time. The\nnext iteration will be based on the two latest patches above, so it\nstill makes sense to review them.\n\nAs for EXPLAIN ANALYZE support, it will require changes to core, but\nthis can be done separately.\n\n\nI'm re-reading the thread, and I have to admit I'm utterly confused what is the current plan, what features it's supposed to provide and whether it will solve the use case I'm most interested in. Oleksandr, could you please post a summary explaining that?\n\nMy use case for this functionality is debugging of long-running queries, particularly getting EXPLAIN ANALYZE for them. In such cases I either can't run the EXPLAIN ANALYZE manually because it will either run forever (just like the query) and may not be the same (e.g. due to recent ANALYZE). So we need to extract the data from the process executing the query.\n\nI'm not essentially opposed to doing this in an extension (better an extension than nothing), but I don't quite see how you could to do that from pg_stat_statements or auto_explain. AFAIK both extensions merely use hooks before/after the executor, and therefore can't do anything in between (while the query is actually running).\n\nPerhaps you don't intend to solve this particular use case? Which use cases are you aiming to solve, then? Could you explain?Hi Tomas.Thanks for your interest in this patch!My motivation is the same as your use case: having a long-running query, be able to look inside this exact query run by this exact backend.I admit the evolution of ideas in this patch can be very confusing: we were trying a number of different approaches, w/o thinking deeply on the implications, just to have a proof of concept.\nMaybe all we need to do is add another hook somewhere in the executor, and push the explain analyze into pg_stat_statements once in a while, entirely eliminating the need for inter-process communication (signals, queues, ...).\n\nI'm pretty sure we don't need this for \"short\" queries, because in those cases we have other means to get the explain analyze (e.g. running the query again or auto_explain). So I can imagine having a rather high threshold (say, 60 seconds or even more), and we'd only push the explain analyze after crossing it. And then we'd only update it once in a while - say, again every 60 seconds.\n\nOf course, this might be configurable by two GUCs:\n\n pg_stat_statements.explain_analyze_threshold = 60 # -1 is \"off\"\n pg_stat_statements.explain_analyze_refresh = 60\n\nFWIW I'd still prefer having \"EXPLAIN ANALYZE\" in core, but better this than nothing.Yes, this is how pg_stat_statements idea comes into play: even if we implement support for online EXPLAIN ANALYZE, enabling it for every query is an overkill, but if you don't enable it from the query start, there is no way to enable it later on as the query has already progressed. So in order to know for which queries it makes sense to enable this feature, we need to know what is the query's expected run time, thus pg_stat_statements seems like a natural place to obtain this information and/or trigger the behavior.I'm also all for simplification of the underlying communication mechanism: shared memory queues are neat, but not necessarily the best way to handle it. As for the use of signals: I believe this was a red herring, it will make the code much less fragile if the progressing backend itself will publish intermediary EXPLAIN ANALYZE reports for other backends to read.The EXPLAIN (w/o ANALYZE) we can do completely as an extension: no core support required. To enable ANALYZE it will require a little hacking around Instrumentation methods: otherwise the Explain functions just crash when run in the middle of the query.Hope that makes it clear.--Alex","msg_date":"Thu, 17 Dec 2015 10:45:32 +0100","msg_from":"\"Shulgin, Oleksandr\" <oleksandr.shulgin@zalando.de>","msg_from_op":true,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"On Thu, Dec 17, 2015 at 6:45 PM, Shulgin, Oleksandr\n<oleksandr.shulgin@zalando.de> wrote:\n> On Wed, Dec 16, 2015 at 8:39 PM, Tomas Vondra <tomas.vondra@2ndquadrant.com>\n> wrote:\n>> On 12/01/2015 10:34 AM, Shulgin, Oleksandr wrote:\n>>>\n>>>\n>>> I have the plans to make something from this on top of\n>>> pg_stat_statements and auto_explain, as I've mentioned last time. The\n>>> next iteration will be based on the two latest patches above, so it\n>>> still makes sense to review them.\n>>>\n>>> As for EXPLAIN ANALYZE support, it will require changes to core, but\n>>> this can be done separately.\n>>\n>> I'm re-reading the thread, and I have to admit I'm utterly confused what\n>> is the current plan, what features it's supposed to provide and whether it\n>> will solve the use case I'm most interested in. Oleksandr, could you please\n>> post a summary explaining that?\n>>\n>> My use case for this functionality is debugging of long-running queries,\n>> particularly getting EXPLAIN ANALYZE for them. In such cases I either can't\n>> run the EXPLAIN ANALYZE manually because it will either run forever (just\n>> like the query) and may not be the same (e.g. due to recent ANALYZE). So we\n>> need to extract the data from the process executing the query.\n>>\n>> I'm not essentially opposed to doing this in an extension (better an\n>> extension than nothing), but I don't quite see how you could to do that from\n>> pg_stat_statements or auto_explain. AFAIK both extensions merely use hooks\n>> before/after the executor, and therefore can't do anything in between (while\n>> the query is actually running).\n>>\n>> Perhaps you don't intend to solve this particular use case? Which use\n>> cases are you aiming to solve, then? Could you explain?\n>\n> Thanks for your interest in this patch!\n>\n> My motivation is the same as your use case: having a long-running query, be\n> able to look inside this exact query run by this exact backend.\n>\n> I admit the evolution of ideas in this patch can be very confusing: we were\n> trying a number of different approaches, w/o thinking deeply on the\n> implications, just to have a proof of concept.\n\nIt's great to see ideas of concepts and things to help address those\nissues, at least we are agreeing that there is a hole in the\ninstrumentation and that it would be nice to fill it with something.\nStill, it is not completely clear which approach would be taken. Is it\nfair to mark the current patch as returned with feedback then?\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 24 Dec 2015 11:23:02 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"2015-12-24 3:23 GMT+01:00 Michael Paquier <michael.paquier@gmail.com>:\n\n> On Thu, Dec 17, 2015 at 6:45 PM, Shulgin, Oleksandr\n> <oleksandr.shulgin@zalando.de> wrote:\n> > On Wed, Dec 16, 2015 at 8:39 PM, Tomas Vondra <\n> tomas.vondra@2ndquadrant.com>\n> > wrote:\n> >> On 12/01/2015 10:34 AM, Shulgin, Oleksandr wrote:\n> >>>\n> >>>\n> >>> I have the plans to make something from this on top of\n> >>> pg_stat_statements and auto_explain, as I've mentioned last time. The\n> >>> next iteration will be based on the two latest patches above, so it\n> >>> still makes sense to review them.\n> >>>\n> >>> As for EXPLAIN ANALYZE support, it will require changes to core, but\n> >>> this can be done separately.\n> >>\n> >> I'm re-reading the thread, and I have to admit I'm utterly confused what\n> >> is the current plan, what features it's supposed to provide and whether\n> it\n> >> will solve the use case I'm most interested in. Oleksandr, could you\n> please\n> >> post a summary explaining that?\n> >>\n> >> My use case for this functionality is debugging of long-running queries,\n> >> particularly getting EXPLAIN ANALYZE for them. In such cases I either\n> can't\n> >> run the EXPLAIN ANALYZE manually because it will either run forever\n> (just\n> >> like the query) and may not be the same (e.g. due to recent ANALYZE).\n> So we\n> >> need to extract the data from the process executing the query.\n> >>\n> >> I'm not essentially opposed to doing this in an extension (better an\n> >> extension than nothing), but I don't quite see how you could to do that\n> from\n> >> pg_stat_statements or auto_explain. AFAIK both extensions merely use\n> hooks\n> >> before/after the executor, and therefore can't do anything in between\n> (while\n> >> the query is actually running).\n> >>\n> >> Perhaps you don't intend to solve this particular use case? Which use\n> >> cases are you aiming to solve, then? Could you explain?\n> >\n> > Thanks for your interest in this patch!\n> >\n> > My motivation is the same as your use case: having a long-running query,\n> be\n> > able to look inside this exact query run by this exact backend.\n> >\n> > I admit the evolution of ideas in this patch can be very confusing: we\n> were\n> > trying a number of different approaches, w/o thinking deeply on the\n> > implications, just to have a proof of concept.\n>\n> It's great to see ideas of concepts and things to help address those\n> issues, at least we are agreeing that there is a hole in the\n> instrumentation and that it would be nice to fill it with something.\n> Still, it is not completely clear which approach would be taken. Is it\n> fair to mark the current patch as returned with feedback then?\n>\n\n+1\n\nPavel\n\n\n> --\n> Michael\n>\n\n2015-12-24 3:23 GMT+01:00 Michael Paquier <michael.paquier@gmail.com>:On Thu, Dec 17, 2015 at 6:45 PM, Shulgin, Oleksandr\n<oleksandr.shulgin@zalando.de> wrote:\n> On Wed, Dec 16, 2015 at 8:39 PM, Tomas Vondra <tomas.vondra@2ndquadrant.com>\n> wrote:\n>> On 12/01/2015 10:34 AM, Shulgin, Oleksandr wrote:\n>>>\n>>>\n>>> I have the plans to make something from this on top of\n>>> pg_stat_statements and auto_explain, as I've mentioned last time. The\n>>> next iteration will be based on the two latest patches above, so it\n>>> still makes sense to review them.\n>>>\n>>> As for EXPLAIN ANALYZE support, it will require changes to core, but\n>>> this can be done separately.\n>>\n>> I'm re-reading the thread, and I have to admit I'm utterly confused what\n>> is the current plan, what features it's supposed to provide and whether it\n>> will solve the use case I'm most interested in. Oleksandr, could you please\n>> post a summary explaining that?\n>>\n>> My use case for this functionality is debugging of long-running queries,\n>> particularly getting EXPLAIN ANALYZE for them. In such cases I either can't\n>> run the EXPLAIN ANALYZE manually because it will either run forever (just\n>> like the query) and may not be the same (e.g. due to recent ANALYZE). So we\n>> need to extract the data from the process executing the query.\n>>\n>> I'm not essentially opposed to doing this in an extension (better an\n>> extension than nothing), but I don't quite see how you could to do that from\n>> pg_stat_statements or auto_explain. AFAIK both extensions merely use hooks\n>> before/after the executor, and therefore can't do anything in between (while\n>> the query is actually running).\n>>\n>> Perhaps you don't intend to solve this particular use case? Which use\n>> cases are you aiming to solve, then? Could you explain?\n>\n> Thanks for your interest in this patch!\n>\n> My motivation is the same as your use case: having a long-running query, be\n> able to look inside this exact query run by this exact backend.\n>\n> I admit the evolution of ideas in this patch can be very confusing: we were\n> trying a number of different approaches, w/o thinking deeply on the\n> implications, just to have a proof of concept.\n\nIt's great to see ideas of concepts and things to help address those\nissues, at least we are agreeing that there is a hole in the\ninstrumentation and that it would be nice to fill it with something.\nStill, it is not completely clear which approach would be taken. Is it\nfair to mark the current patch as returned with feedback then?+1Pavel \n--\nMichael","msg_date":"Thu, 24 Dec 2015 05:57:10 +0100","msg_from":"Pavel Stehule <pavel.stehule@gmail.com>","msg_from_op":false,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"},{"msg_contents":"On Thu, Dec 24, 2015 at 1:57 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:\n>\n>\n> 2015-12-24 3:23 GMT+01:00 Michael Paquier <michael.paquier@gmail.com>:\n>>\n>> On Thu, Dec 17, 2015 at 6:45 PM, Shulgin, Oleksandr\n>> <oleksandr.shulgin@zalando.de> wrote:\n>> > On Wed, Dec 16, 2015 at 8:39 PM, Tomas Vondra\n>> > <tomas.vondra@2ndquadrant.com>\n>> > wrote:\n>> >> On 12/01/2015 10:34 AM, Shulgin, Oleksandr wrote:\n>> >>>\n>> >>>\n>> >>> I have the plans to make something from this on top of\n>> >>> pg_stat_statements and auto_explain, as I've mentioned last time. The\n>> >>> next iteration will be based on the two latest patches above, so it\n>> >>> still makes sense to review them.\n>> >>>\n>> >>> As for EXPLAIN ANALYZE support, it will require changes to core, but\n>> >>> this can be done separately.\n>> >>\n>> >> I'm re-reading the thread, and I have to admit I'm utterly confused\n>> >> what\n>> >> is the current plan, what features it's supposed to provide and whether\n>> >> it\n>> >> will solve the use case I'm most interested in. Oleksandr, could you\n>> >> please\n>> >> post a summary explaining that?\n>> >>\n>> >> My use case for this functionality is debugging of long-running\n>> >> queries,\n>> >> particularly getting EXPLAIN ANALYZE for them. In such cases I either\n>> >> can't\n>> >> run the EXPLAIN ANALYZE manually because it will either run forever\n>> >> (just\n>> >> like the query) and may not be the same (e.g. due to recent ANALYZE).\n>> >> So we\n>> >> need to extract the data from the process executing the query.\n>> >>\n>> >> I'm not essentially opposed to doing this in an extension (better an\n>> >> extension than nothing), but I don't quite see how you could to do that\n>> >> from\n>> >> pg_stat_statements or auto_explain. AFAIK both extensions merely use\n>> >> hooks\n>> >> before/after the executor, and therefore can't do anything in between\n>> >> (while\n>> >> the query is actually running).\n>> >>\n>> >> Perhaps you don't intend to solve this particular use case? Which use\n>> >> cases are you aiming to solve, then? Could you explain?\n>> >\n>> > Thanks for your interest in this patch!\n>> >\n>> > My motivation is the same as your use case: having a long-running query,\n>> > be\n>> > able to look inside this exact query run by this exact backend.\n>> >\n>> > I admit the evolution of ideas in this patch can be very confusing: we\n>> > were\n>> > trying a number of different approaches, w/o thinking deeply on the\n>> > implications, just to have a proof of concept.\n>>\n>> It's great to see ideas of concepts and things to help address those\n>> issues, at least we are agreeing that there is a hole in the\n>> instrumentation and that it would be nice to fill it with something.\n>> Still, it is not completely clear which approach would be taken. Is it\n>> fair to mark the current patch as returned with feedback then?\n>\n>\n> +1\n\nSo, done this way. We could always move it to next CF if someone\nwishes to move on. But at this point that would be a different\napproach than what was proposed first..\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 24 Dec 2015 16:36:48 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: On-demand running query plans using auto_explain and signals"}],"string":"[\n {\n \"msg_contents\": \"Hello,\\n\\nThe other day I've rediscovered the exciting idea of using signals to dump\\na backend's currently executed query plan, which, it turns out, was already\\nproposed by Pavel and Simon in these threads:\\n\\nhttp://www.postgresql.org/message-id/flat/CAFj8pRA-DuzkmDtu52CiUgb0P7TVri_B8LtjMJfWcnr1LPts6w@mail.gmail.com\\n\\nhttp://www.postgresql.org/message-id/flat/CAFj8pRDEo24joEg4UFRDYeFADFTw-jw_=t=kPwOyDW=v=g1Fhg@mail.gmail.com#\\n\\nUnfortunately, the latest one is missing an actual patch (or the attachment\\nwas scrubbed) and I'm really surprised that the idea didn't take off then.\\n\\n\\nWhile evaluating it myself I've decided to simply patch auto_explain module\\nwhich is now in contrib, so presumably should be available to a broad\\naudience. Proof-of-concept patch against master is attached (a patch for\\nan older branch like 9.0 requires trivial manual effort to adapt).\\n\\nWhile I can see the value of in-core support for this, realistically this\\nis unlikely to be included in 9.5, but an ad hoc patch could be useful long\\nbefore that happens.\\n\\nWhat this patch does is simply dump the plan of the query being run by the\\nexecutor to the log when signaled with SIGUSR1. The auto_explain module\\nmust be loaded to the backend beforehand of course,\\nsession_preload_libraries seems like the place to do that cluster-wide.\\n\\nProbably using SIGUSR2 would be more appropriate, but I'm not sure if there\\nare other extensions out there that might be already using it for some\\nother reason (well, I do not know that for SIGUSR1 either). Looking at the\\ncurrent state of affairs in procsignal_sigusr1_handler() makes me believe\\nit should be pretty safe to catch the signal like I do. Or is that not the\\ncase?\\n\\nThe current_query_desc probably needs to be a stack-like structure in order\\nto keep track of the nested queries correctly, but it works in the simplest\\ncases.\\n\\n\\nWhat would be even more useful is including stats from the running query in\\nthe explain output, if you're a willing to pay for a (hopefully small)\\noverhead. Unfortunately, that doesn't work out of the box: if you enable\\nthe auto_explain.log_analyze and friends in the .conf-file, you either get\\nall zero counts, or if you're really unlucky, an error from InstrEndLoop():\\n\\nERROR: InstrEndLoop called on running node\\n\\nThe latest patch in this area I could found is this one:\\nhttp://www.postgresql.org/message-id/87wsn82lda.fsf@oxford.xeocode.com\\n\\n From what I can see, there's no way around this problem short of hacking\\nInstrEndLoop... Did anything change in this area since 2008 possibly? I\\nwould really love to have a way to make this work with existing un-patched\\nservers.\\n\\nCheers!\\n--\\nAlex\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Sat, 29 Aug 2015 17:33:22 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On 2015-08-29 17:33:22 +0200, Shulgin, Oleksandr wrote:\\n> Probably using SIGUSR2 would be more appropriate, but I'm not sure if there\\n> are other extensions out there that might be already using it for some\\n> other reason (well, I do not know that for SIGUSR1 either). Looking at the\\n> current state of affairs in procsignal_sigusr1_handler() makes me believe\\n> it should be pretty safe to catch the signal like I do. Or is that not the\\n> case?\\n\\nYou can catch signals, but you're not allowed to do a lot from\\nthem. Anything allocating memory, acquiring locks, etc. is out - these\\nfunctions aren't reentrant. If you can guarantee that you're not\\ninterrupting any relevant code you can bend those rules, but that's\\nobviously not the case here.\\n\\nCheck out the list of async-signal-safe functions at http://man7.org/linux/man-pages/man7/signal.7.html\\n\\nAndres\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 29 Aug 2015 17:44:12 +0200\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and\\n signals\"\n },\n {\n \"msg_contents\": \"On Sat, Aug 29, 2015 at 5:44 PM, Andres Freund <andres@anarazel.de> wrote:\\n\\n> On 2015-08-29 17:33:22 +0200, Shulgin, Oleksandr wrote:\\n> > Probably using SIGUSR2 would be more appropriate, but I'm not sure if\\n> there\\n> > are other extensions out there that might be already using it for some\\n> > other reason (well, I do not know that for SIGUSR1 either). Looking at\\n> the\\n> > current state of affairs in procsignal_sigusr1_handler() makes me believe\\n> > it should be pretty safe to catch the signal like I do. Or is that not\\n> the\\n> > case?\\n>\\n> You can catch signals, but you're not allowed to do a lot from\\n> them. Anything allocating memory, acquiring locks, etc. is out - these\\n> functions aren't reentrant. If you can guarantee that you're not\\n> interrupting any relevant code you can bend those rules, but that's\\n> obviously not the case here.\\n>\\n> Check out the list of async-signal-safe functions at\\n> http://man7.org/linux/man-pages/man7/signal.7.html\\n\\n\\nGood point. There's still hope to set a flag and process it later on.\\nWill have to check if it's possible to stay in the scope of a loaded module\\nthough.\\n\\nOn Sat, Aug 29, 2015 at 5:44 PM, Andres Freund <andres@anarazel.de> wrote:On 2015-08-29 17:33:22 +0200, Shulgin, Oleksandr wrote:\\n> Probably using SIGUSR2 would be more appropriate, but I'm not sure if there\\n> are other extensions out there that might be already using it for some\\n> other reason (well, I do not know that for SIGUSR1 either). Looking at the\\n> current state of affairs in procsignal_sigusr1_handler() makes me believe\\n> it should be pretty safe to catch the signal like I do. Or is that not the\\n> case?\\n\\nYou can catch signals, but you're not allowed to do a lot from\\nthem. Anything allocating memory, acquiring locks, etc. is out - these\\nfunctions aren't reentrant. If you can guarantee that you're not\\ninterrupting any relevant code you can bend those rules, but that's\\nobviously not the case here.\\n\\nCheck out the list of async-signal-safe functions at http://man7.org/linux/man-pages/man7/signal.7.htmlGood point. There's still hope to set a flag and process it later on. Will have to check if it's possible to stay in the scope of a loaded module though.\",\n \"msg_date\": \"Sat, 29 Aug 2015 18:25:52 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-08-29 18:25 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Sat, Aug 29, 2015 at 5:44 PM, Andres Freund <andres@anarazel.de> wrote:\\n>\\n>> On 2015-08-29 17:33:22 +0200, Shulgin, Oleksandr wrote:\\n>> > Probably using SIGUSR2 would be more appropriate, but I'm not sure if\\n>> there\\n>> > are other extensions out there that might be already using it for some\\n>> > other reason (well, I do not know that for SIGUSR1 either). Looking at\\n>> the\\n>> > current state of affairs in procsignal_sigusr1_handler() makes me\\n>> believe\\n>> > it should be pretty safe to catch the signal like I do. Or is that not\\n>> the\\n>> > case?\\n>>\\n>> You can catch signals, but you're not allowed to do a lot from\\n>> them. Anything allocating memory, acquiring locks, etc. is out - these\\n>> functions aren't reentrant. If you can guarantee that you're not\\n>> interrupting any relevant code you can bend those rules, but that's\\n>> obviously not the case here.\\n>>\\n>> Check out the list of async-signal-safe functions at\\n>> http://man7.org/linux/man-pages/man7/signal.7.html\\n>\\n>\\n> Good point. There's still hope to set a flag and process it later on.\\n> Will have to check if it's possible to stay in the scope of a loaded module\\n> though.\\n>\\n\\nI had a workable prototype - and It was implemented very similar as\\nhandling CANCEL\\n\\nPavel\\n\\n2015-08-29 18:25 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Sat, Aug 29, 2015 at 5:44 PM, Andres Freund <andres@anarazel.de> wrote:On 2015-08-29 17:33:22 +0200, Shulgin, Oleksandr wrote:\\n> Probably using SIGUSR2 would be more appropriate, but I'm not sure if there\\n> are other extensions out there that might be already using it for some\\n> other reason (well, I do not know that for SIGUSR1 either). Looking at the\\n> current state of affairs in procsignal_sigusr1_handler() makes me believe\\n> it should be pretty safe to catch the signal like I do. Or is that not the\\n> case?\\n\\nYou can catch signals, but you're not allowed to do a lot from\\nthem. Anything allocating memory, acquiring locks, etc. is out - these\\nfunctions aren't reentrant. If you can guarantee that you're not\\ninterrupting any relevant code you can bend those rules, but that's\\nobviously not the case here.\\n\\nCheck out the list of async-signal-safe functions at http://man7.org/linux/man-pages/man7/signal.7.htmlGood point. There's still hope to set a flag and process it later on. Will have to check if it's possible to stay in the scope of a loaded module though.I had a workable prototype - and It was implemented very similar as handling CANCEL Pavel\",\n \"msg_date\": \"Sat, 29 Aug 2015 18:27:59 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On 2015-08-29 18:27:59 +0200, Pavel Stehule wrote:\\n> 2015-08-29 18:25 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n> > Good point. There's still hope to set a flag and process it later on.\\n> > Will have to check if it's possible to stay in the scope of a loaded module\\n> > though.\\n\\n> I had a workable prototype - and It was implemented very similar as\\n> handling CANCEL\\n\\nWhere did you put the handling of that kind of interrupt? Directly into\\nProcessInterrupts()?\\n\\nAndres\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 29 Aug 2015 18:36:03 +0200\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and\\n signals\"\n },\n {\n \"msg_contents\": \"2015-08-29 18:36 GMT+02:00 Andres Freund <andres@anarazel.de>:\\n\\n> On 2015-08-29 18:27:59 +0200, Pavel Stehule wrote:\\n> > 2015-08-29 18:25 GMT+02:00 Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de>\\n> > > Good point. There's still hope to set a flag and process it later on.\\n> > > Will have to check if it's possible to stay in the scope of a loaded\\n> module\\n> > > though.\\n>\\n> > I had a workable prototype - and It was implemented very similar as\\n> > handling CANCEL\\n>\\n> Where did you put the handling of that kind of interrupt? Directly into\\n> ProcessInterrupts()?\\n>\\n\\nProbably. I don't remember it well, but it need hack code - it cannot be\\nused from extension.\\n\\nPavel\\n\\n\\n>\\n> Andres\\n>\\n\\n2015-08-29 18:36 GMT+02:00 Andres Freund <andres@anarazel.de>:On 2015-08-29 18:27:59 +0200, Pavel Stehule wrote:\\n> 2015-08-29 18:25 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n> > Good point. There's still hope to set a flag and process it later on.\\n> > Will have to check if it's possible to stay in the scope of a loaded module\\n> > though.\\n\\n> I had a workable prototype - and It was implemented very similar as\\n> handling CANCEL\\n\\nWhere did you put the handling of that kind of interrupt? Directly into\\nProcessInterrupts()?Probably. I don't remember it well, but it need hack code - it cannot be used from extension.Pavel \\n\\nAndres\",\n \"msg_date\": \"Sat, 29 Aug 2015 19:31:04 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Aug 29, 2015 7:31 PM, \\\"Pavel Stehule\\\" <pavel.stehule@gmail.com> wrote:\\n>\\n>\\n>\\n> 2015-08-29 18:36 GMT+02:00 Andres Freund <andres@anarazel.de>:\\n>>\\n>> On 2015-08-29 18:27:59 +0200, Pavel Stehule wrote:\\n>> > 2015-08-29 18:25 GMT+02:00 Shulgin, Oleksandr <\\noleksandr.shulgin@zalando.de>\\n>> > > Good point. There's still hope to set a flag and process it later\\non.\\n>> > > Will have to check if it's possible to stay in the scope of a loaded\\nmodule\\n>> > > though.\\n>>\\n>> > I had a workable prototype - and It was implemented very similar as\\n>> > handling CANCEL\\n>>\\n>> Where did you put the handling of that kind of interrupt? Directly into\\n>> ProcessInterrupts()?\\n>\\n>\\n> Probably. I don't remember it well, but it need hack code - it cannot be\\nused from extension.\\n\\nDo you still have the code somewhere around? Did it see production use?\\n\\nThanks!\\n--\\nAlex\\n\\nOn Aug 29, 2015 7:31 PM, \\\"Pavel Stehule\\\" <pavel.stehule@gmail.com> wrote:\\n>\\n>\\n>\\n> 2015-08-29 18:36 GMT+02:00 Andres Freund <andres@anarazel.de>:\\n>>\\n>> On 2015-08-29 18:27:59 +0200, Pavel Stehule wrote:\\n>> > 2015-08-29 18:25 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n>> > > Good point. There's still hope to set a flag and process it later on.\\n>> > > Will have to check if it's possible to stay in the scope of a loaded module\\n>> > > though.\\n>>\\n>> > I had a workable prototype - and It was implemented very similar as\\n>> > handling CANCEL\\n>>\\n>> Where did you put the handling of that kind of interrupt? Directly into\\n>> ProcessInterrupts()?\\n>\\n>\\n> Probably. I don't remember it well, but it need hack code - it cannot be used from extension.\\nDo you still have the code somewhere around? Did it see production use?\\nThanks!\\n--\\nAlex\",\n \"msg_date\": \"Sun, 30 Aug 2015 10:30:51 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-08-30 10:30 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Aug 29, 2015 7:31 PM, \\\"Pavel Stehule\\\" <pavel.stehule@gmail.com> wrote:\\n> >\\n> >\\n> >\\n> > 2015-08-29 18:36 GMT+02:00 Andres Freund <andres@anarazel.de>:\\n> >>\\n> >> On 2015-08-29 18:27:59 +0200, Pavel Stehule wrote:\\n> >> > 2015-08-29 18:25 GMT+02:00 Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de>\\n> >> > > Good point. There's still hope to set a flag and process it later\\n> on.\\n> >> > > Will have to check if it's possible to stay in the scope of a\\n> loaded module\\n> >> > > though.\\n> >>\\n> >> > I had a workable prototype - and It was implemented very similar as\\n> >> > handling CANCEL\\n> >>\\n> >> Where did you put the handling of that kind of interrupt? Directly into\\n> >> ProcessInterrupts()?\\n> >\\n> >\\n> > Probably. I don't remember it well, but it need hack code - it cannot be\\n> used from extension.\\n>\\n> Do you still have the code somewhere around? Did it see production use?\\n>\\nI am not sure I am able to find it - I'll try. We didn't use it on\\nproduction.\\n\\n\\n> Thanks!\\n> --\\n> Alex\\n>\\n\\n2015-08-30 10:30 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Aug 29, 2015 7:31 PM, \\\"Pavel Stehule\\\" <pavel.stehule@gmail.com> wrote:\\n>\\n>\\n>\\n> 2015-08-29 18:36 GMT+02:00 Andres Freund <andres@anarazel.de>:\\n>>\\n>> On 2015-08-29 18:27:59 +0200, Pavel Stehule wrote:\\n>> > 2015-08-29 18:25 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n>> > > Good point. There's still hope to set a flag and process it later on.\\n>> > > Will have to check if it's possible to stay in the scope of a loaded module\\n>> > > though.\\n>>\\n>> > I had a workable prototype - and It was implemented very similar as\\n>> > handling CANCEL\\n>>\\n>> Where did you put the handling of that kind of interrupt? Directly into\\n>> ProcessInterrupts()?\\n>\\n>\\n> Probably. I don't remember it well, but it need hack code - it cannot be used from extension.\\nDo you still have the code somewhere around? Did it see production use?I am not sure I am able to find it - I'll try. We didn't use it on production. \\nThanks!\\n--\\nAlex\",\n \"msg_date\": \"Sun, 30 Aug 2015 10:34:48 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-08-30 10:34 GMT+02:00 Pavel Stehule <pavel.stehule@gmail.com>:\\n\\n>\\n>\\n> 2015-08-30 10:30 GMT+02:00 Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de>:\\n>\\n>> On Aug 29, 2015 7:31 PM, \\\"Pavel Stehule\\\" <pavel.stehule@gmail.com> wrote:\\n>> >\\n>> >\\n>> >\\n>> > 2015-08-29 18:36 GMT+02:00 Andres Freund <andres@anarazel.de>:\\n>> >>\\n>> >> On 2015-08-29 18:27:59 +0200, Pavel Stehule wrote:\\n>> >> > 2015-08-29 18:25 GMT+02:00 Shulgin, Oleksandr <\\n>> oleksandr.shulgin@zalando.de>\\n>> >> > > Good point. There's still hope to set a flag and process it later\\n>> on.\\n>> >> > > Will have to check if it's possible to stay in the scope of a\\n>> loaded module\\n>> >> > > though.\\n>> >>\\n>> >> > I had a workable prototype - and It was implemented very similar as\\n>> >> > handling CANCEL\\n>> >>\\n>> >> Where did you put the handling of that kind of interrupt? Directly into\\n>> >> ProcessInterrupts()?\\n>> >\\n>> >\\n>> > Probably. I don't remember it well, but it need hack code - it cannot\\n>> be used from extension.\\n>>\\n>> Do you still have the code somewhere around? Did it see production use?\\n>>\\n> I sent it to mailing list year ago\\n\\nhttp://www.postgresql.org/message-id/CAFj8pRAXcS9B8ABgiM-zauVgGqDhPZOaRz5YSp1_Nhv9HP8nKw@mail.gmail.com\\n\\nRegards\\n\\nPavel\\n\\n\\n\\n> I am not sure I am able to find it - I'll try. We didn't use it on\\n> production.\\n>\\n>\\n>> Thanks!\\n>> --\\n>> Alex\\n>>\\n>\\n>\\n\\n2015-08-30 10:34 GMT+02:00 Pavel Stehule <pavel.stehule@gmail.com>:2015-08-30 10:30 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Aug 29, 2015 7:31 PM, \\\"Pavel Stehule\\\" <pavel.stehule@gmail.com> wrote:\\n>\\n>\\n>\\n> 2015-08-29 18:36 GMT+02:00 Andres Freund <andres@anarazel.de>:\\n>>\\n>> On 2015-08-29 18:27:59 +0200, Pavel Stehule wrote:\\n>> > 2015-08-29 18:25 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n>> > > Good point. There's still hope to set a flag and process it later on.\\n>> > > Will have to check if it's possible to stay in the scope of a loaded module\\n>> > > though.\\n>>\\n>> > I had a workable prototype - and It was implemented very similar as\\n>> > handling CANCEL\\n>>\\n>> Where did you put the handling of that kind of interrupt? Directly into\\n>> ProcessInterrupts()?\\n>\\n>\\n> Probably. I don't remember it well, but it need hack code - it cannot be used from extension.\\nDo you still have the code somewhere around? Did it see production use?I sent it to mailing list year agohttp://www.postgresql.org/message-id/CAFj8pRAXcS9B8ABgiM-zauVgGqDhPZOaRz5YSp1_Nhv9HP8nKw@mail.gmail.comRegardsPavel I am not sure I am able to find it - I'll try. We didn't use it on production. \\nThanks!\\n--\\nAlex\",\n \"msg_date\": \"Mon, 31 Aug 2015 06:15:31 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \">\\n> Do you still have the code somewhere around? Did it see production use?\\n>>>\\n>> I sent it to mailing list year ago\\n>\\n>\\n> http://www.postgresql.org/message-id/CAFj8pRAXcS9B8ABgiM-zauVgGqDhPZOaRz5YSp1_Nhv9HP8nKw@mail.gmail.com\\n>\\n\\nAh, thanks! Somehow I've missed this mail. You didn't add the patch to a\\ncommitfest back then I think?\\n\\n--\\nAlex\\n\\nDo you still have the code somewhere around? Did it see production use?I sent it to mailing list year agohttp://www.postgresql.org/message-id/CAFj8pRAXcS9B8ABgiM-zauVgGqDhPZOaRz5YSp1_Nhv9HP8nKw@mail.gmail.comAh, thanks! Somehow I've missed this mail. You didn't add the patch to a commitfest back then I think?--Alex\",\n \"msg_date\": \"Mon, 31 Aug 2015 11:30:13 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-08-31 11:30 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> Do you still have the code somewhere around? Did it see production use?\\n>>>>\\n>>> I sent it to mailing list year ago\\n>>\\n>>\\n>> http://www.postgresql.org/message-id/CAFj8pRAXcS9B8ABgiM-zauVgGqDhPZOaRz5YSp1_Nhv9HP8nKw@mail.gmail.com\\n>>\\n>\\n> Ah, thanks! Somehow I've missed this mail. You didn't add the patch to a\\n> commitfest back then I think?\\n>\\n\\nI had no time to finish this patch - there is few issues in signal handling\\nand returning back result - but still I want it :) - and what I know -\\nalmost all other SQL db has similar functionality.\\n\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n2015-08-31 11:30 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:Do you still have the code somewhere around? Did it see production use?I sent it to mailing list year agohttp://www.postgresql.org/message-id/CAFj8pRAXcS9B8ABgiM-zauVgGqDhPZOaRz5YSp1_Nhv9HP8nKw@mail.gmail.comAh, thanks! Somehow I've missed this mail. You didn't add the patch to a commitfest back then I think?I had no time to finish this patch - there is few issues in signal handling and returning back result - but still I want it :) - and what I know - almost all other SQL db has similar functionality. --Alex\",\n \"msg_date\": \"Mon, 31 Aug 2015 12:35:45 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 31, 2015 at 12:35 PM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n\\n>\\n>>>\\n>>> http://www.postgresql.org/message-id/CAFj8pRAXcS9B8ABgiM-zauVgGqDhPZOaRz5YSp1_Nhv9HP8nKw@mail.gmail.com\\n>>>\\n>>\\n>> Ah, thanks! Somehow I've missed this mail. You didn't add the patch to\\n>> a commitfest back then I think?\\n>>\\n>\\n> I had no time to finish this patch - there is few issues in signal\\n> handling and returning back result - but still I want it :) - and what I\\n> know - almost all other SQL db has similar functionality.\\n>\\n\\nI've updated the patch for the current master and also added some\\nunexpected parameters handling, so attached is a v2.\\n\\nI'd say we should hide the so-designed pg_cmdstatus() interface behind more\\nfriendly calls like pg_explain_backend() and pg_backend_progress() to give\\nsome naming examples, to remove the need for magic numbers in the second\\narg.\\n\\nWhat I've found missing in this approach is the insight into nested\\nexecutor runs, so that if you're running a \\\"SELECT my_func()\\\", you only see\\nthis outer query in the pg_cmdstatus() output. With the auto_explain\\napproach, by hooking into executor I was able to capture the nested queries\\nand their plans as well.\\n\\nIt's conceptually trivial to add some code to use the Executor hooks here,\\nbut I don't see any precedent for this except for contrib modules\\n(auto_explain and pg_stat_statements), I'm just not sure if that would be\\nOK-ish.\\n\\nAnd when we solve that, there is another problem of having a sane interface\\nto query the nested plans. For a psql user, probably the most interesting\\nwould be the topmost (level=1) and the innermost (e.g. level=-1) plans. We\\nmight also want to provide a full nesting of plans in a structured format\\nlike JSON or... *cough* XML, for programs to consume and display nicely\\nwith folding and stuff.\\n\\nAnd the most interesting would be making instrumentation work with all of\\nthe above.\\n\\nI'm adding this to the next CF.\\n\\n--\\nAlex\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 31 Aug 2015 19:09:15 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"Hi\\n\\n2015-08-31 19:09 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Mon, Aug 31, 2015 at 12:35 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n>\\n>>\\n>>>>\\n>>>> http://www.postgresql.org/message-id/CAFj8pRAXcS9B8ABgiM-zauVgGqDhPZOaRz5YSp1_Nhv9HP8nKw@mail.gmail.com\\n>>>>\\n>>>\\n>>> Ah, thanks! Somehow I've missed this mail. You didn't add the patch to\\n>>> a commitfest back then I think?\\n>>>\\n>>\\n>> I had no time to finish this patch - there is few issues in signal\\n>> handling and returning back result - but still I want it :) - and what I\\n>> know - almost all other SQL db has similar functionality.\\n>>\\n>\\n> I've updated the patch for the current master and also added some\\n> unexpected parameters handling, so attached is a v2.\\n>\\n\\nThank you very much\\n\\n\\n>\\n> I'd say we should hide the so-designed pg_cmdstatus() interface behind\\n> more friendly calls like pg_explain_backend() and pg_backend_progress() to\\n> give some naming examples, to remove the need for magic numbers in the\\n> second arg.\\n>\\n\\nI had similar idea - this is good enough for start, but target interface\\niis based on integration with EXPLAIN statement\\n\\nsome like EXPLAIN PROCESS or EXPLAIN PID or EXPLAIN VERBOSE PID ..\\n\\n\\n>\\n> What I've found missing in this approach is the insight into nested\\n> executor runs, so that if you're running a \\\"SELECT my_func()\\\", you only see\\n> this outer query in the pg_cmdstatus() output. With the auto_explain\\n> approach, by hooking into executor I was able to capture the nested queries\\n> and their plans as well.\\n>\\n\\nI understand - originally I didn't think about nested queries, but it is\\ngood idea and probably not a problem:\\n\\nNot for XML and JSON where we can describe nesting simply\\n\\nIt is little bit harder for plain text - but we can use similar format that\\nis used for subplans or some like\\n\\ntop query:\\n SELECT fx()\\n\\nnested (1. level) query:\\n SELECT ....\\n\\n\\n>\\n> It's conceptually trivial to add some code to use the Executor hooks here,\\n> but I don't see any precedent for this except for contrib modules\\n> (auto_explain and pg_stat_statements), I'm just not sure if that would be\\n> OK-ish.\\n>\\n> And when we solve that, there is another problem of having a sane\\n> interface to query the nested plans. For a psql user, probably the most\\n> interesting would be the topmost (level=1) and the innermost (e.g.\\n> level=-1) plans. We might also want to provide a full nesting of plans in\\n> a structured format like JSON or... *cough* XML, for programs to consume\\n> and display nicely with folding and stuff.\\n>\\n> And the most interesting would be making instrumentation work with all of\\n> the above.\\n>\\n\\nthe important functionality is drawing complete text of query - it was my\\noriginal motivation, because I had not way how to get complete query before\\nits finishing\\n\\nProbably the communication between processes should be more complex :( -\\nthe SHM queue should be used there, because some plans can be terrible long.\\n\\nThe using shared write buffer (one for all) is too simply solution probably\\n- good for prototype, but not good for core.\\n\\nI have a idea about communication:\\n\\n1. caller prepare buffer, shm queue and signalize target process -\\nparameter is pid od caller\\n2. target process fills a write buffer and close queue\\n3. caller show data and close buffer, close queue\\n\\nNow almost all code for communication is in upstream - the missing part is\\ninjection one end of queue to any process dynamicaly.\\n\\nRegards\\n\\nPavel\\n\\n>\\n> I'm adding this to the next CF.\\n>\\n> --\\n> Alex\\n>\\n\\nHi2015-08-31 19:09 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Mon, Aug 31, 2015 at 12:35 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:http://www.postgresql.org/message-id/CAFj8pRAXcS9B8ABgiM-zauVgGqDhPZOaRz5YSp1_Nhv9HP8nKw@mail.gmail.comAh, thanks! Somehow I've missed this mail. You didn't add the patch to a commitfest back then I think?I had no time to finish this patch - there is few issues in signal handling and returning back result - but still I want it :) - and what I know - almost all other SQL db has similar functionality. I've updated the patch for the current master and also added some unexpected parameters handling, so attached is a v2.Thank you very much I'd say we should hide the so-designed pg_cmdstatus() interface behind more friendly calls like pg_explain_backend() and pg_backend_progress() to give some naming examples, to remove the need for magic numbers in the second arg.I had similar idea - this is good enough for start, but target interface iis based on integration with EXPLAIN statementsome like EXPLAIN PROCESS or EXPLAIN PID or EXPLAIN VERBOSE PID .. What I've found missing in this approach is the insight into nested executor runs, so that if you're running a \\\"SELECT my_func()\\\", you only see this outer query in the pg_cmdstatus() output. With the auto_explain approach, by hooking into executor I was able to capture the nested queries and their plans as well.I understand - originally I didn't think about nested queries, but it is good idea and probably not a problem:Not for XML and JSON where we can describe nesting simplyIt is little bit harder for plain text - but we can use similar format that is used for subplans or some liketop query: SELECT fx()nested (1. level) query: SELECT .... It's conceptually trivial to add some code to use the Executor hooks here, but I don't see any precedent for this except for contrib modules (auto_explain and pg_stat_statements), I'm just not sure if that would be OK-ish.And when we solve that, there is another problem of having a sane interface to query the nested plans. For a psql user, probably the most interesting would be the topmost (level=1) and the innermost (e.g. level=-1) plans. We might also want to provide a full nesting of plans in a structured format like JSON or... *cough* XML, for programs to consume and display nicely with folding and stuff.And the most interesting would be making instrumentation work with all of the above.the important functionality is drawing complete text of query - it was my original motivation, because I had not way how to get complete query before its finishingProbably the communication between processes should be more complex :( - the SHM queue should be used there, because some plans can be terrible long.The using shared write buffer (one for all) is too simply solution probably - good for prototype, but not good for core.I have a idea about communication:1. caller prepare buffer, shm queue and signalize target process - parameter is pid od caller2. target process fills a write buffer and close queue3. caller show data and close buffer, close queueNow almost all code for communication is in upstream - the missing part is injection one end of queue to any process dynamicaly. RegardsPavel I'm adding this to the next CF.--Alex\",\n \"msg_date\": \"Tue, 1 Sep 2015 07:40:01 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \">\\n> I'd say we should hide the so-designed pg_cmdstatus() interface behind\\n>> more friendly calls like pg_explain_backend() and pg_backend_progress() to\\n>> give some naming examples, to remove the need for magic numbers in the\\n>> second arg.\\n>>\\n>\\n> I had similar idea - this is good enough for start, but target interface\\n> iis based on integration with EXPLAIN statement\\n>\\n> some like EXPLAIN PROCESS or EXPLAIN PID or EXPLAIN VERBOSE PID ..\\n>\\n\\nYes, that's another way to do it.\\n\\nthe important functionality is drawing complete text of query - it was my\\n> original motivation, because I had not way how to get complete query before\\n> its finishing\\n>\\n> Probably the communication between processes should be more complex :( -\\n> the SHM queue should be used there, because some plans can be terrible long.\\n>\\n> The using shared write buffer (one for all) is too simply solution\\n> probably - good for prototype, but not good for core.\\n>\\n> I have a idea about communication:\\n>\\n> 1. caller prepare buffer, shm queue and signalize target process -\\n> parameter is pid od caller\\n> 2. target process fills a write buffer and close queue\\n> 3. caller show data and close buffer, close queue\\n>\\n> Now almost all code for communication is in upstream - the missing part is\\n> injection one end of queue to any process dynamicaly.\\n>\\n\\nI'm not familiar with the shared memory handling, but could we not allocate\\njust enough shared memory to fit the data we're going to write instead of\\nthe fixed 8k? It's not that we cannot know the length of the resulting\\nplan text in advance.\\n\\nI think we can remove buffer_is_free/buffer_holds_data and just use the\\nbuffer != NULL to check if there's some data to be read (and buffer == NULL\\nto check if we can write).\\n\\n--\\nAlex\\n\\nI'd say we should hide the so-designed pg_cmdstatus() interface behind more friendly calls like pg_explain_backend() and pg_backend_progress() to give some naming examples, to remove the need for magic numbers in the second arg.I had similar idea - this is good enough for start, but target interface iis based on integration with EXPLAIN statementsome like EXPLAIN PROCESS or EXPLAIN PID or EXPLAIN VERBOSE PID ..Yes, that's another way to do it.the important functionality is drawing complete text of query - it was my original motivation, because I had not way how to get complete query before its finishingProbably the communication between processes should be more complex :( - the SHM queue should be used there, because some plans can be terrible long.The using shared write buffer (one for all) is too simply solution probably - good for prototype, but not good for core.I have a idea about communication:1. caller prepare buffer, shm queue and signalize target process - parameter is pid od caller2. target process fills a write buffer and close queue3. caller show data and close buffer, close queueNow almost all code for communication is in upstream - the missing part is injection one end of queue to any process dynamicaly. I'm not familiar with the shared memory handling, but could we not allocate just enough shared memory to fit the data we're going to write instead of the fixed 8k? It's not that we cannot know the length of the resulting plan text in advance.I think we can remove buffer_is_free/buffer_holds_data and just use the buffer != NULL to check if there's some data to be read (and buffer == NULL to check if we can write).--Alex\",\n \"msg_date\": \"Tue, 1 Sep 2015 15:00:58 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-01 15:00 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> I'd say we should hide the so-designed pg_cmdstatus() interface behind\\n>>> more friendly calls like pg_explain_backend() and pg_backend_progress() to\\n>>> give some naming examples, to remove the need for magic numbers in the\\n>>> second arg.\\n>>>\\n>>\\n>> I had similar idea - this is good enough for start, but target interface\\n>> iis based on integration with EXPLAIN statement\\n>>\\n>> some like EXPLAIN PROCESS or EXPLAIN PID or EXPLAIN VERBOSE PID ..\\n>>\\n>\\n> Yes, that's another way to do it.\\n>\\n> the important functionality is drawing complete text of query - it was my\\n>> original motivation, because I had not way how to get complete query before\\n>> its finishing\\n>>\\n>> Probably the communication between processes should be more complex :( -\\n>> the SHM queue should be used there, because some plans can be terrible long.\\n>>\\n>> The using shared write buffer (one for all) is too simply solution\\n>> probably - good for prototype, but not good for core.\\n>>\\n>> I have a idea about communication:\\n>>\\n>> 1. caller prepare buffer, shm queue and signalize target process -\\n>> parameter is pid od caller\\n>> 2. target process fills a write buffer and close queue\\n>> 3. caller show data and close buffer, close queue\\n>>\\n>> Now almost all code for communication is in upstream - the missing part\\n>> is injection one end of queue to any process dynamicaly.\\n>>\\n>\\n> I'm not familiar with the shared memory handling, but could we not\\n> allocate just enough shared memory to fit the data we're going to write\\n> instead of the fixed 8k? It's not that we cannot know the length of the\\n> resulting plan text in advance.\\n>\\n\\nthe shared memory cannot be reused - (released) :(, so allocating enough\\nmemory is not effective. More - in this moment it has not sense. Shared\\nmemory queue can do almost all work.\\n\\n\\n>\\n> I think we can remove buffer_is_free/buffer_holds_data and just use the\\n> buffer != NULL to check if there's some data to be read (and buffer == NULL\\n> to check if we can write).\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n2015-09-01 15:00 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:I'd say we should hide the so-designed pg_cmdstatus() interface behind more friendly calls like pg_explain_backend() and pg_backend_progress() to give some naming examples, to remove the need for magic numbers in the second arg.I had similar idea - this is good enough for start, but target interface iis based on integration with EXPLAIN statementsome like EXPLAIN PROCESS or EXPLAIN PID or EXPLAIN VERBOSE PID ..Yes, that's another way to do it.the important functionality is drawing complete text of query - it was my original motivation, because I had not way how to get complete query before its finishingProbably the communication between processes should be more complex :( - the SHM queue should be used there, because some plans can be terrible long.The using shared write buffer (one for all) is too simply solution probably - good for prototype, but not good for core.I have a idea about communication:1. caller prepare buffer, shm queue and signalize target process - parameter is pid od caller2. target process fills a write buffer and close queue3. caller show data and close buffer, close queueNow almost all code for communication is in upstream - the missing part is injection one end of queue to any process dynamicaly. I'm not familiar with the shared memory handling, but could we not allocate just enough shared memory to fit the data we're going to write instead of the fixed 8k? It's not that we cannot know the length of the resulting plan text in advance.the shared memory cannot be reused - (released) :(, so allocating enough memory is not effective. More - in this moment it has not sense. Shared memory queue can do almost all work. I think we can remove buffer_is_free/buffer_holds_data and just use the buffer != NULL to check if there's some data to be read (and buffer == NULL to check if we can write).--Alex\",\n \"msg_date\": \"Tue, 1 Sep 2015 15:09:52 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \">\\n> I'm not familiar with the shared memory handling, but could we not\\n>> allocate just enough shared memory to fit the data we're going to write\\n>> instead of the fixed 8k? It's not that we cannot know the length of the\\n>> resulting plan text in advance.\\n>>\\n>\\n> the shared memory cannot be reused - (released) :(, so allocating enough\\n> memory is not effective. More - in this moment it has not sense. Shared\\n> memory queue can do almost all work.\\n>\\n\\nA-ha, I've discovered the shared memory message queue facility and I see\\nhow we can use it.\\n\\nBut do we really need the slots mechanism? Would it not be OK to just let\\nthe LWLock do the sequencing of concurrent requests? Given that we only\\ngoing to use one message queue per cluster, there's not much concurrency\\nyou can gain by introducing slots I believe.\\n\\n--\\nAlex\\n\\nI'm not familiar with the shared memory handling, but could we not allocate just enough shared memory to fit the data we're going to write instead of the fixed 8k? It's not that we cannot know the length of the resulting plan text in advance.the shared memory cannot be reused - (released) :(, so allocating enough memory is not effective. More - in this moment it has not sense. Shared memory queue can do almost all work.A-ha, I've discovered the shared memory message queue facility and I see how we can use it.But do we really need the slots mechanism? Would it not be OK to just let the LWLock do the sequencing of concurrent requests? Given that we only going to use one message queue per cluster, there's not much concurrency you can gain by introducing slots I believe.--Alex\",\n \"msg_date\": \"Tue, 1 Sep 2015 17:20:42 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-01 17:20 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> I'm not familiar with the shared memory handling, but could we not\\n>>> allocate just enough shared memory to fit the data we're going to write\\n>>> instead of the fixed 8k? It's not that we cannot know the length of the\\n>>> resulting plan text in advance.\\n>>>\\n>>\\n>> the shared memory cannot be reused - (released) :(, so allocating enough\\n>> memory is not effective. More - in this moment it has not sense. Shared\\n>> memory queue can do almost all work.\\n>>\\n>\\n> A-ha, I've discovered the shared memory message queue facility and I see\\n> how we can use it.\\n>\\n> But do we really need the slots mechanism? Would it not be OK to just let\\n> the LWLock do the sequencing of concurrent requests? Given that we only\\n> going to use one message queue per cluster, there's not much concurrency\\n> you can gain by introducing slots I believe.\\n>\\n\\nI afraid of problems on production. When you have a queue related to any\\nprocess, then all problems should be off after end of processes. One\\nmessage queue per cluster needs restart cluster when some pathological\\nproblems are - and you cannot restart cluster in production week, sometimes\\nweeks. The slots are more robust.\\n\\nPavel\\n\\n\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n2015-09-01 17:20 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:I'm not familiar with the shared memory handling, but could we not allocate just enough shared memory to fit the data we're going to write instead of the fixed 8k? It's not that we cannot know the length of the resulting plan text in advance.the shared memory cannot be reused - (released) :(, so allocating enough memory is not effective. More - in this moment it has not sense. Shared memory queue can do almost all work.A-ha, I've discovered the shared memory message queue facility and I see how we can use it.But do we really need the slots mechanism? Would it not be OK to just let the LWLock do the sequencing of concurrent requests? Given that we only going to use one message queue per cluster, there's not much concurrency you can gain by introducing slots I believe.I afraid of problems on production. When you have a queue related to any process, then all problems should be off after end of processes. One message queue per cluster needs restart cluster when some pathological problems are - and you cannot restart cluster in production week, sometimes weeks. The slots are more robust.Pavel --Alex\",\n \"msg_date\": \"Tue, 1 Sep 2015 19:02:04 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 7:02 PM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n\\n>\\n>> But do we really need the slots mechanism? Would it not be OK to just\\n>> let the LWLock do the sequencing of concurrent requests? Given that we\\n>> only going to use one message queue per cluster, there's not much\\n>> concurrency you can gain by introducing slots I believe.\\n>>\\n>\\n> I afraid of problems on production. When you have a queue related to any\\n> process, then all problems should be off after end of processes. One\\n> message queue per cluster needs restart cluster when some pathological\\n> problems are - and you cannot restart cluster in production week, sometimes\\n> weeks. The slots are more robust.\\n>\\n\\nYes, but in your implementation the slots themselves don't have a\\nqueue/buffer. Did you intend to have a message queue per slot?\\n\\nWhat sort of pathological problems are you concerned of? The communicating\\nbackends should just detach from the message queue properly and have some\\ntimeout configured to prevent deadlocks. Other than that, I don't see how\\nhaving N slots really help the problem: in case of pathological problems\\nyou will just deplete them all sooner or later.\\n\\n--\\nAlex\\n\\nOn Tue, Sep 1, 2015 at 7:02 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:But do we really need the slots mechanism? Would it not be OK to just let the LWLock do the sequencing of concurrent requests? Given that we only going to use one message queue per cluster, there's not much concurrency you can gain by introducing slots I believe.I afraid of problems on production. When you have a queue related to any process, then all problems should be off after end of processes. One message queue per cluster needs restart cluster when some pathological problems are - and you cannot restart cluster in production week, sometimes weeks. The slots are more robust.Yes, but in your implementation the slots themselves don't have a queue/buffer. Did you intend to have a message queue per slot?What sort of pathological problems are you concerned of? The communicating backends should just detach from the message queue properly and have some timeout configured to prevent deadlocks. Other than that, I don't see how having N slots really help the problem: in case of pathological problems you will just deplete them all sooner or later.--Alex\",\n \"msg_date\": \"Wed, 2 Sep 2015 11:01:00 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-02 11:01 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Tue, Sep 1, 2015 at 7:02 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n>\\n>>\\n>>> But do we really need the slots mechanism? Would it not be OK to just\\n>>> let the LWLock do the sequencing of concurrent requests? Given that we\\n>>> only going to use one message queue per cluster, there's not much\\n>>> concurrency you can gain by introducing slots I believe.\\n>>>\\n>>\\n>> I afraid of problems on production. When you have a queue related to any\\n>> process, then all problems should be off after end of processes. One\\n>> message queue per cluster needs restart cluster when some pathological\\n>> problems are - and you cannot restart cluster in production week, sometimes\\n>> weeks. The slots are more robust.\\n>>\\n>\\n> Yes, but in your implementation the slots themselves don't have a\\n> queue/buffer. Did you intend to have a message queue per slot?\\n>\\n\\nThe message queue cannot be reused, so I expect one slot per caller to be\\nused passing parameters, - message queue will be created/released by demand\\nby caller.\\n\\n\\n>\\n> What sort of pathological problems are you concerned of? The\\n> communicating backends should just detach from the message queue properly\\n> and have some timeout configured to prevent deadlocks. Other than that, I\\n> don't see how having N slots really help the problem: in case of\\n> pathological problems you will just deplete them all sooner or later.\\n>\\n\\nI afraid of unexpected problems :) - any part of signal handling or\\nmultiprocess communication is fragile. Slots are simple and simply attached\\nto any process without necessity to alloc/free some memory.\\n\\nPavel\\n\\n\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n2015-09-02 11:01 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Tue, Sep 1, 2015 at 7:02 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:But do we really need the slots mechanism? Would it not be OK to just let the LWLock do the sequencing of concurrent requests? Given that we only going to use one message queue per cluster, there's not much concurrency you can gain by introducing slots I believe.I afraid of problems on production. When you have a queue related to any process, then all problems should be off after end of processes. One message queue per cluster needs restart cluster when some pathological problems are - and you cannot restart cluster in production week, sometimes weeks. The slots are more robust.Yes, but in your implementation the slots themselves don't have a queue/buffer. Did you intend to have a message queue per slot?The message queue cannot be reused, so I expect one slot per caller to be used passing parameters, - message queue will be created/released by demand by caller. What sort of pathological problems are you concerned of? The communicating backends should just detach from the message queue properly and have some timeout configured to prevent deadlocks. Other than that, I don't see how having N slots really help the problem: in case of pathological problems you will just deplete them all sooner or later.I afraid of unexpected problems :) - any part of signal handling or multiprocess communication is fragile. Slots are simple and simply attached to any process without necessity to alloc/free some memory. Pavel --Alex\",\n \"msg_date\": \"Wed, 2 Sep 2015 11:16:21 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 11:16 AM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n\\n>\\n>\\n> 2015-09-02 11:01 GMT+02:00 Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de>:\\n>\\n>> On Tue, Sep 1, 2015 at 7:02 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n>> wrote:\\n>>\\n>>>\\n>>>> But do we really need the slots mechanism? Would it not be OK to just\\n>>>> let the LWLock do the sequencing of concurrent requests? Given that we\\n>>>> only going to use one message queue per cluster, there's not much\\n>>>> concurrency you can gain by introducing slots I believe.\\n>>>>\\n>>>\\n>>> I afraid of problems on production. When you have a queue related to any\\n>>> process, then all problems should be off after end of processes. One\\n>>> message queue per cluster needs restart cluster when some pathological\\n>>> problems are - and you cannot restart cluster in production week, sometimes\\n>>> weeks. The slots are more robust.\\n>>>\\n>>\\n>> Yes, but in your implementation the slots themselves don't have a\\n>> queue/buffer. Did you intend to have a message queue per slot?\\n>>\\n>\\n> The message queue cannot be reused, so I expect one slot per caller to be\\n> used passing parameters, - message queue will be created/released by demand\\n> by caller.\\n>\\n\\nI don't believe a message queue cannot really be reused. What would stop\\nus from calling shm_mq_create() on the queue struct again?\\n\\nTo give you an idea, in my current prototype I have only the following\\nstruct:\\n\\ntypedef struct {\\nLWLock *lock;\\n/*CmdStatusInfoSlot slots[CMDINFO_SLOTS];*/\\npid_t target_pid;\\npid_t sender_pid;\\nint request_type;\\nint result_code;\\nshm_mq buffer;\\n} CmdStatusInfo;\\n\\nAn instance of this is allocated on shared memory once, using BUFFER_SIZE\\nof 8k.\\n\\nIn pg_cmdstatus() I lock on the LWLock to check if target_pid is 0, then it\\nmeans nobody else is using this communication channel at the moment. If\\nthat's the case, I set the pids and request_type and initialize the mq\\nbuffer. Otherwise I just sleep and retry acquiring the lock (a timeout\\nshould be added here probably).\\n\\nWhat sort of pathological problems are you concerned of? The communicating\\n>> backends should just detach from the message queue properly and have some\\n>> timeout configured to prevent deadlocks. Other than that, I don't see how\\n>> having N slots really help the problem: in case of pathological problems\\n>> you will just deplete them all sooner or later.\\n>>\\n>\\n> I afraid of unexpected problems :) - any part of signal handling or\\n> multiprocess communication is fragile. Slots are simple and simply attached\\n> to any process without necessity to alloc/free some memory.\\n>\\n\\nYes, but do slots solve the actual problem? If there is only one message\\nqueue, you still have the same problem regardless of the number of slots\\nyou decide to have.\\n\\n--\\nAlex\\n\\nOn Wed, Sep 2, 2015 at 11:16 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-02 11:01 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Tue, Sep 1, 2015 at 7:02 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:But do we really need the slots mechanism? Would it not be OK to just let the LWLock do the sequencing of concurrent requests? Given that we only going to use one message queue per cluster, there's not much concurrency you can gain by introducing slots I believe.I afraid of problems on production. When you have a queue related to any process, then all problems should be off after end of processes. One message queue per cluster needs restart cluster when some pathological problems are - and you cannot restart cluster in production week, sometimes weeks. The slots are more robust.Yes, but in your implementation the slots themselves don't have a queue/buffer. Did you intend to have a message queue per slot?The message queue cannot be reused, so I expect one slot per caller to be used passing parameters, - message queue will be created/released by demand by caller.I don't believe a message queue cannot really be reused. What would stop us from calling shm_mq_create() on the queue struct again?To give you an idea, in my current prototype I have only the following struct:typedef struct { LWLock *lock; /*CmdStatusInfoSlot slots[CMDINFO_SLOTS];*/ pid_t target_pid; pid_t sender_pid; int request_type; int result_code; shm_mq buffer;} CmdStatusInfo;An instance of this is allocated on shared memory once, using BUFFER_SIZE of 8k.In pg_cmdstatus() I lock on the LWLock to check if target_pid is 0, then it means nobody else is using this communication channel at the moment. If that's the case, I set the pids and request_type and initialize the mq buffer. Otherwise I just sleep and retry acquiring the lock (a timeout should be added here probably).What sort of pathological problems are you concerned of? The communicating backends should just detach from the message queue properly and have some timeout configured to prevent deadlocks. Other than that, I don't see how having N slots really help the problem: in case of pathological problems you will just deplete them all sooner or later.I afraid of unexpected problems :) - any part of signal handling or multiprocess communication is fragile. Slots are simple and simply attached to any process without necessity to alloc/free some memory.Yes, but do slots solve the actual problem? If there is only one message queue, you still have the same problem regardless of the number of slots you decide to have.--Alex\",\n \"msg_date\": \"Wed, 2 Sep 2015 12:36:20 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-02 12:36 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Wed, Sep 2, 2015 at 11:16 AM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n>\\n>>\\n>>\\n>> 2015-09-02 11:01 GMT+02:00 Shulgin, Oleksandr <\\n>> oleksandr.shulgin@zalando.de>:\\n>>\\n>>> On Tue, Sep 1, 2015 at 7:02 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n>>> wrote:\\n>>>\\n>>>>\\n>>>>> But do we really need the slots mechanism? Would it not be OK to just\\n>>>>> let the LWLock do the sequencing of concurrent requests? Given that we\\n>>>>> only going to use one message queue per cluster, there's not much\\n>>>>> concurrency you can gain by introducing slots I believe.\\n>>>>>\\n>>>>\\n>>>> I afraid of problems on production. When you have a queue related to\\n>>>> any process, then all problems should be off after end of processes. One\\n>>>> message queue per cluster needs restart cluster when some pathological\\n>>>> problems are - and you cannot restart cluster in production week, sometimes\\n>>>> weeks. The slots are more robust.\\n>>>>\\n>>>\\n>>> Yes, but in your implementation the slots themselves don't have a\\n>>> queue/buffer. Did you intend to have a message queue per slot?\\n>>>\\n>>\\n>> The message queue cannot be reused, so I expect one slot per caller to be\\n>> used passing parameters, - message queue will be created/released by demand\\n>> by caller.\\n>>\\n>\\n> I don't believe a message queue cannot really be reused. What would stop\\n> us from calling shm_mq_create() on the queue struct again?\\n>\\n\\nyou cannot to change recipient later\\n\\n\\n>\\n> To give you an idea, in my current prototype I have only the following\\n> struct:\\n>\\n> typedef struct {\\n> LWLock *lock;\\n> /*CmdStatusInfoSlot slots[CMDINFO_SLOTS];*/\\n> pid_t target_pid;\\n> pid_t sender_pid;\\n> int request_type;\\n> int result_code;\\n> shm_mq buffer;\\n> } CmdStatusInfo;\\n>\\n> An instance of this is allocated on shared memory once, using BUFFER_SIZE\\n> of 8k.\\n>\\n> In pg_cmdstatus() I lock on the LWLock to check if target_pid is 0, then\\n> it means nobody else is using this communication channel at the moment. If\\n> that's the case, I set the pids and request_type and initialize the mq\\n> buffer. Otherwise I just sleep and retry acquiring the lock (a timeout\\n> should be added here probably).\\n>\\n> What sort of pathological problems are you concerned of? The\\n>>> communicating backends should just detach from the message queue properly\\n>>> and have some timeout configured to prevent deadlocks. Other than that, I\\n>>> don't see how having N slots really help the problem: in case of\\n>>> pathological problems you will just deplete them all sooner or later.\\n>>>\\n>>\\n>> I afraid of unexpected problems :) - any part of signal handling or\\n>> multiprocess communication is fragile. Slots are simple and simply attached\\n>> to any process without necessity to alloc/free some memory.\\n>>\\n>\\n> Yes, but do slots solve the actual problem? If there is only one message\\n> queue, you still have the same problem regardless of the number of slots\\n> you decide to have.\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n2015-09-02 12:36 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Wed, Sep 2, 2015 at 11:16 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-02 11:01 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Tue, Sep 1, 2015 at 7:02 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:But do we really need the slots mechanism? Would it not be OK to just let the LWLock do the sequencing of concurrent requests? Given that we only going to use one message queue per cluster, there's not much concurrency you can gain by introducing slots I believe.I afraid of problems on production. When you have a queue related to any process, then all problems should be off after end of processes. One message queue per cluster needs restart cluster when some pathological problems are - and you cannot restart cluster in production week, sometimes weeks. The slots are more robust.Yes, but in your implementation the slots themselves don't have a queue/buffer. Did you intend to have a message queue per slot?The message queue cannot be reused, so I expect one slot per caller to be used passing parameters, - message queue will be created/released by demand by caller.I don't believe a message queue cannot really be reused. What would stop us from calling shm_mq_create() on the queue struct again?you cannot to change recipient later To give you an idea, in my current prototype I have only the following struct:typedef struct { LWLock *lock; /*CmdStatusInfoSlot slots[CMDINFO_SLOTS];*/ pid_t target_pid; pid_t sender_pid; int request_type; int result_code; shm_mq buffer;} CmdStatusInfo;An instance of this is allocated on shared memory once, using BUFFER_SIZE of 8k.In pg_cmdstatus() I lock on the LWLock to check if target_pid is 0, then it means nobody else is using this communication channel at the moment. If that's the case, I set the pids and request_type and initialize the mq buffer. Otherwise I just sleep and retry acquiring the lock (a timeout should be added here probably).What sort of pathological problems are you concerned of? The communicating backends should just detach from the message queue properly and have some timeout configured to prevent deadlocks. Other than that, I don't see how having N slots really help the problem: in case of pathological problems you will just deplete them all sooner or later.I afraid of unexpected problems :) - any part of signal handling or multiprocess communication is fragile. Slots are simple and simply attached to any process without necessity to alloc/free some memory.Yes, but do slots solve the actual problem? If there is only one message queue, you still have the same problem regardless of the number of slots you decide to have.--Alex\",\n \"msg_date\": \"Wed, 2 Sep 2015 14:56:03 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 2:56 PM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n\\n>\\n>\\n> 2015-09-02 12:36 GMT+02:00 Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de>:\\n>\\n>> On Wed, Sep 2, 2015 at 11:16 AM, Pavel Stehule <pavel.stehule@gmail.com>\\n>> wrote:\\n>>\\n>>>\\n>>>\\n>>> 2015-09-02 11:01 GMT+02:00 Shulgin, Oleksandr <\\n>>> oleksandr.shulgin@zalando.de>:\\n>>>\\n>>>> On Tue, Sep 1, 2015 at 7:02 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n>>>> wrote:\\n>>>>\\n>>>>>\\n>>>>>> But do we really need the slots mechanism? Would it not be OK to\\n>>>>>> just let the LWLock do the sequencing of concurrent requests? Given that\\n>>>>>> we only going to use one message queue per cluster, there's not much\\n>>>>>> concurrency you can gain by introducing slots I believe.\\n>>>>>>\\n>>>>>\\n>>>>> I afraid of problems on production. When you have a queue related to\\n>>>>> any process, then all problems should be off after end of processes. One\\n>>>>> message queue per cluster needs restart cluster when some pathological\\n>>>>> problems are - and you cannot restart cluster in production week, sometimes\\n>>>>> weeks. The slots are more robust.\\n>>>>>\\n>>>>\\n>>>> Yes, but in your implementation the slots themselves don't have a\\n>>>> queue/buffer. Did you intend to have a message queue per slot?\\n>>>>\\n>>>\\n>>> The message queue cannot be reused, so I expect one slot per caller to\\n>>> be used passing parameters, - message queue will be created/released by\\n>>> demand by caller.\\n>>>\\n>>\\n>> I don't believe a message queue cannot really be reused. What would stop\\n>> us from calling shm_mq_create() on the queue struct again?\\n>>\\n>\\n> you cannot to change recipient later\\n>\\n\\nWell, maybe I'm missing something, but sh_mq_create() will just overwrite\\nthe contents of the struct, so it doesn't care about sender/receiver: only\\nsh_mq_set_sender/receiver() do.\\n\\nOn Wed, Sep 2, 2015 at 2:56 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-02 12:36 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Wed, Sep 2, 2015 at 11:16 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-02 11:01 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Tue, Sep 1, 2015 at 7:02 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:But do we really need the slots mechanism? Would it not be OK to just let the LWLock do the sequencing of concurrent requests? Given that we only going to use one message queue per cluster, there's not much concurrency you can gain by introducing slots I believe.I afraid of problems on production. When you have a queue related to any process, then all problems should be off after end of processes. One message queue per cluster needs restart cluster when some pathological problems are - and you cannot restart cluster in production week, sometimes weeks. The slots are more robust.Yes, but in your implementation the slots themselves don't have a queue/buffer. Did you intend to have a message queue per slot?The message queue cannot be reused, so I expect one slot per caller to be used passing parameters, - message queue will be created/released by demand by caller.I don't believe a message queue cannot really be reused. What would stop us from calling shm_mq_create() on the queue struct again?you cannot to change recipient laterWell, maybe I'm missing something, but sh_mq_create() will just overwrite the contents of the struct, so it doesn't care about sender/receiver: only sh_mq_set_sender/receiver() do.\",\n \"msg_date\": \"Wed, 2 Sep 2015 15:00:40 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-02 15:00 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Wed, Sep 2, 2015 at 2:56 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n>\\n>>\\n>>\\n>> 2015-09-02 12:36 GMT+02:00 Shulgin, Oleksandr <\\n>> oleksandr.shulgin@zalando.de>:\\n>>\\n>>> On Wed, Sep 2, 2015 at 11:16 AM, Pavel Stehule <pavel.stehule@gmail.com>\\n>>> wrote:\\n>>>\\n>>>>\\n>>>>\\n>>>> 2015-09-02 11:01 GMT+02:00 Shulgin, Oleksandr <\\n>>>> oleksandr.shulgin@zalando.de>:\\n>>>>\\n>>>>> On Tue, Sep 1, 2015 at 7:02 PM, Pavel Stehule <pavel.stehule@gmail.com\\n>>>>> > wrote:\\n>>>>>\\n>>>>>>\\n>>>>>>> But do we really need the slots mechanism? Would it not be OK to\\n>>>>>>> just let the LWLock do the sequencing of concurrent requests? Given that\\n>>>>>>> we only going to use one message queue per cluster, there's not much\\n>>>>>>> concurrency you can gain by introducing slots I believe.\\n>>>>>>>\\n>>>>>>\\n>>>>>> I afraid of problems on production. When you have a queue related to\\n>>>>>> any process, then all problems should be off after end of processes. One\\n>>>>>> message queue per cluster needs restart cluster when some pathological\\n>>>>>> problems are - and you cannot restart cluster in production week, sometimes\\n>>>>>> weeks. The slots are more robust.\\n>>>>>>\\n>>>>>\\n>>>>> Yes, but in your implementation the slots themselves don't have a\\n>>>>> queue/buffer. Did you intend to have a message queue per slot?\\n>>>>>\\n>>>>\\n>>>> The message queue cannot be reused, so I expect one slot per caller to\\n>>>> be used passing parameters, - message queue will be created/released by\\n>>>> demand by caller.\\n>>>>\\n>>>\\n>>> I don't believe a message queue cannot really be reused. What would\\n>>> stop us from calling shm_mq_create() on the queue struct again?\\n>>>\\n>>\\n>> you cannot to change recipient later\\n>>\\n>\\n> Well, maybe I'm missing something, but sh_mq_create() will just overwrite\\n> the contents of the struct, so it doesn't care about sender/receiver: only\\n> sh_mq_set_sender/receiver() do.\\n>\\n\\nif you create sh_mq from scratch, then you can reuse structure.\\n\\nPavel\\n\\n2015-09-02 15:00 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Wed, Sep 2, 2015 at 2:56 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-02 12:36 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Wed, Sep 2, 2015 at 11:16 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-02 11:01 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Tue, Sep 1, 2015 at 7:02 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:But do we really need the slots mechanism? Would it not be OK to just let the LWLock do the sequencing of concurrent requests? Given that we only going to use one message queue per cluster, there's not much concurrency you can gain by introducing slots I believe.I afraid of problems on production. When you have a queue related to any process, then all problems should be off after end of processes. One message queue per cluster needs restart cluster when some pathological problems are - and you cannot restart cluster in production week, sometimes weeks. The slots are more robust.Yes, but in your implementation the slots themselves don't have a queue/buffer. Did you intend to have a message queue per slot?The message queue cannot be reused, so I expect one slot per caller to be used passing parameters, - message queue will be created/released by demand by caller.I don't believe a message queue cannot really be reused. What would stop us from calling shm_mq_create() on the queue struct again?you cannot to change recipient laterWell, maybe I'm missing something, but sh_mq_create() will just overwrite the contents of the struct, so it doesn't care about sender/receiver: only sh_mq_set_sender/receiver() do.if you create sh_mq from scratch, then you can reuse structure.Pavel\",\n \"msg_date\": \"Wed, 2 Sep 2015 15:04:28 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 3:04 PM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n>\\n>\\n>> Well, maybe I'm missing something, but sh_mq_create() will just overwrite\\n>> the contents of the struct, so it doesn't care about sender/receiver: only\\n>> sh_mq_set_sender/receiver() do.\\n>>\\n>\\n> if you create sh_mq from scratch, then you can reuse structure.\\n>\\n\\nThat was my plan. I'm now close to actually compiling this stuff, we'll\\nsee if it works in the simplest case at least. :-)\\n\\nOn Wed, Sep 2, 2015 at 3:04 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:Well, maybe I'm missing something, but sh_mq_create() will just overwrite the contents of the struct, so it doesn't care about sender/receiver: only sh_mq_set_sender/receiver() do.if you create sh_mq from scratch, then you can reuse structure.That was my plan. I'm now close to actually compiling this stuff, we'll see if it works in the simplest case at least. :-)\",\n \"msg_date\": \"Wed, 2 Sep 2015 15:07:35 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 3:07 PM, Shulgin, Oleksandr <\\noleksandr.shulgin@zalando.de> wrote:\\n\\n> On Wed, Sep 2, 2015 at 3:04 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n>>\\n>>\\n>>> Well, maybe I'm missing something, but sh_mq_create() will just\\n>>> overwrite the contents of the struct, so it doesn't care about\\n>>> sender/receiver: only sh_mq_set_sender/receiver() do.\\n>>>\\n>>\\n>> if you create sh_mq from scratch, then you can reuse structure.\\n>>\\n>\\nPlease find attached a v3.\\n\\nIt uses a shared memory queue and also has the ability to capture plans\\nnested deeply in the call stack. Not sure about using the executor hook,\\nsince this is not an extension...\\n\\nThe LWLock is used around initializing/cleaning the shared struct and the\\nmessage queue, the IO synchronization is handled by the message queue\\nitself. After some testing with concurrent pgbench and intentionally deep\\nrecursive plpgsql functions (up to 700 plpgsql stack frames) I think this\\napproach can work. Unless there's some theoretical problem I'm just not\\naware of. :-)\\n\\nComments welcome!\\n--\\nAlex\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Thu, 3 Sep 2015 18:30:54 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"Hi\\n\\n\\n\\n\\n2015-09-03 18:30 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Wed, Sep 2, 2015 at 3:07 PM, Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de> wrote:\\n>\\n>> On Wed, Sep 2, 2015 at 3:04 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n>> wrote:\\n>>>\\n>>>\\n>>>> Well, maybe I'm missing something, but sh_mq_create() will just\\n>>>> overwrite the contents of the struct, so it doesn't care about\\n>>>> sender/receiver: only sh_mq_set_sender/receiver() do.\\n>>>>\\n>>>\\n>>> if you create sh_mq from scratch, then you can reuse structure.\\n>>>\\n>>\\n> Please find attached a v3.\\n>\\n> It uses a shared memory queue and also has the ability to capture plans\\n> nested deeply in the call stack. Not sure about using the executor hook,\\n> since this is not an extension...\\n>\\n> The LWLock is used around initializing/cleaning the shared struct and the\\n> message queue, the IO synchronization is handled by the message queue\\n> itself. After some testing with concurrent pgbench and intentionally deep\\n> recursive plpgsql functions (up to 700 plpgsql stack frames) I think this\\n> approach can work. Unless there's some theoretical problem I'm just not\\n> aware of. :-)\\n>\\n>\\nComments welcome!\\n>\\n\\nI am not pretty happy from this design. Only one EXPLAIN PID/GET STATUS in\\none time can be executed per server - I remember lot of queries that\\ndoesn't handle CANCEL well ~ doesn't handle interrupt well, and this can be\\nunfriendly. Cannot to say if it is good enough for first iteration. This is\\nfunctionality that can be used for diagnostic when you have overloaded\\nserver and this risk looks too high (for me). The idea of receive slot can\\nto solve this risk well. The difference from this code should not be too\\nbig - although it is not trivial - needs work with PGPROC.\\n\\n\\n\\nOther smaller issues:\\n\\n* probably sending line by line is useless - shm_mq_send can pass bigger\\ndata when nowait = false\\n* pg_usleep(1000L); - it is related to single point resource\\n\\nSome ideas:\\n\\n* this code share some important parts with auto_explain (query stack) -\\nand because it should be in core (due handling signal if I remember well),\\nit can be first step of integration auto_explain to core.\\n\\n\\n\\n> --\\n> Alex\\n>\\n>\\n\\nHi2015-09-03 18:30 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Wed, Sep 2, 2015 at 3:07 PM, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote:On Wed, Sep 2, 2015 at 3:04 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:Well, maybe I'm missing something, but sh_mq_create() will just overwrite the contents of the struct, so it doesn't care about sender/receiver: only sh_mq_set_sender/receiver() do.if you create sh_mq from scratch, then you can reuse structure.Please find attached a v3.It uses a shared memory queue and also has the ability to capture plans nested deeply in the call stack. Not sure about using the executor hook, since this is not an extension...The LWLock is used around initializing/cleaning the shared struct and the message queue, the IO synchronization is handled by the message queue itself. After some testing with concurrent pgbench and intentionally deep recursive plpgsql functions (up to 700 plpgsql stack frames) I think this approach can work. Unless there's some theoretical problem I'm just not aware of. :-) Comments welcome!I am not pretty happy from this design. Only one EXPLAIN PID/GET STATUS in one time can be executed per server - I remember lot of queries that doesn't handle CANCEL well ~ doesn't handle interrupt well, and this can be unfriendly. Cannot to say if it is good enough for first iteration. This is functionality that can be used for diagnostic when you have overloaded server and this risk looks too high (for me). The idea of receive slot can to solve this risk well. The difference from this code should not be too big - although it is not trivial - needs work with PGPROC.Other smaller issues:* probably sending line by line is useless - shm_mq_send can pass bigger data when nowait = false* pg_usleep(1000L); - it is related to single point resourceSome ideas:* this code share some important parts with auto_explain (query stack) - and because it should be in core (due handling signal if I remember well), it can be first step of integration auto_explain to core. --Alex\",\n \"msg_date\": \"Thu, 3 Sep 2015 22:06:59 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-03 22:06 GMT+02:00 Pavel Stehule <pavel.stehule@gmail.com>:\\n\\n> Hi\\n>\\n>\\n>\\n>\\n> 2015-09-03 18:30 GMT+02:00 Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de>:\\n>\\n>> On Wed, Sep 2, 2015 at 3:07 PM, Shulgin, Oleksandr <\\n>> oleksandr.shulgin@zalando.de> wrote:\\n>>\\n>>> On Wed, Sep 2, 2015 at 3:04 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n>>> wrote:\\n>>>>\\n>>>>\\n>>>>> Well, maybe I'm missing something, but sh_mq_create() will just\\n>>>>> overwrite the contents of the struct, so it doesn't care about\\n>>>>> sender/receiver: only sh_mq_set_sender/receiver() do.\\n>>>>>\\n>>>>\\n>>>> if you create sh_mq from scratch, then you can reuse structure.\\n>>>>\\n>>>\\n>> Please find attached a v3.\\n>>\\n>> It uses a shared memory queue and also has the ability to capture plans\\n>> nested deeply in the call stack. Not sure about using the executor hook,\\n>> since this is not an extension...\\n>>\\n>> The LWLock is used around initializing/cleaning the shared struct and the\\n>> message queue, the IO synchronization is handled by the message queue\\n>> itself. After some testing with concurrent pgbench and intentionally deep\\n>> recursive plpgsql functions (up to 700 plpgsql stack frames) I think this\\n>> approach can work. Unless there's some theoretical problem I'm just not\\n>> aware of. :-)\\n>>\\n>>\\n> Comments welcome!\\n>>\\n>\\n> I am not pretty happy from this design. Only one EXPLAIN PID/GET STATUS in\\n> one time can be executed per server - I remember lot of queries that\\n> doesn't handle CANCEL well ~ doesn't handle interrupt well, and this can be\\n> unfriendly. Cannot to say if it is good enough for first iteration. This is\\n> functionality that can be used for diagnostic when you have overloaded\\n> server and this risk looks too high (for me). The idea of receive slot can\\n> to solve this risk well (and can be used elsewhere). The difference from\\n> this code should not be too big - although it is not trivial - needs work\\n> with PGPROC. The opinion of our multiprocess experts can be interesting.\\n> Maybe I am too careful.\\n>\\n\\n\\n\\n>\\n>\\n>\\n> Other smaller issues:\\n>\\n> * probably sending line by line is useless - shm_mq_send can pass bigger\\n> data when nowait = false\\n> * pg_usleep(1000L); - it is related to single point resource\\n>\\n> Some ideas:\\n>\\n> * this code share some important parts with auto_explain (query stack) -\\n> and because it should be in core (due handling signal if I remember well),\\n> it can be first step of integration auto_explain to core.\\n>\\n>\\n>\\n>> --\\n>> Alex\\n>>\\n>>\\n>\\n\\n2015-09-03 22:06 GMT+02:00 Pavel Stehule <pavel.stehule@gmail.com>:Hi2015-09-03 18:30 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Wed, Sep 2, 2015 at 3:07 PM, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote:On Wed, Sep 2, 2015 at 3:04 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:Well, maybe I'm missing something, but sh_mq_create() will just overwrite the contents of the struct, so it doesn't care about sender/receiver: only sh_mq_set_sender/receiver() do.if you create sh_mq from scratch, then you can reuse structure.Please find attached a v3.It uses a shared memory queue and also has the ability to capture plans nested deeply in the call stack. Not sure about using the executor hook, since this is not an extension...The LWLock is used around initializing/cleaning the shared struct and the message queue, the IO synchronization is handled by the message queue itself. After some testing with concurrent pgbench and intentionally deep recursive plpgsql functions (up to 700 plpgsql stack frames) I think this approach can work. Unless there's some theoretical problem I'm just not aware of. :-) Comments welcome!I am not pretty happy from this design. Only one EXPLAIN PID/GET STATUS in one time can be executed per server - I remember lot of queries that doesn't handle CANCEL well ~ doesn't handle interrupt well, and this can be unfriendly. Cannot to say if it is good enough for first iteration. This is functionality that can be used for diagnostic when you have overloaded server and this risk looks too high (for me). The idea of receive slot can to solve this risk well (and can be used elsewhere). The difference from this code should not be too big - although it is not trivial - needs work with PGPROC. The opinion of our multiprocess experts can be interesting. Maybe I am too careful. Other smaller issues:* probably sending line by line is useless - shm_mq_send can pass bigger data when nowait = false* pg_usleep(1000L); - it is related to single point resourceSome ideas:* this code share some important parts with auto_explain (query stack) - and because it should be in core (due handling signal if I remember well), it can be first step of integration auto_explain to core. --Alex\",\n \"msg_date\": \"Thu, 3 Sep 2015 22:14:02 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Sep 3, 2015 10:14 PM, \\\"Pavel Stehule\\\" <pavel.stehule@gmail.com> wrote:\\n>>>\\n>>> Please find attached a v3.\\n>>>\\n>>> It uses a shared memory queue and also has the ability to capture plans\\nnested deeply in the call stack. Not sure about using the executor hook,\\nsince this is not an extension...\\n>>>\\n>>> The LWLock is used around initializing/cleaning the shared struct and\\nthe message queue, the IO synchronization is handled by the message queue\\nitself.\\n>>\\n>> I am not pretty happy from this design. Only one EXPLAIN PID/GET STATUS\\nin one time can be executed per server - I remember lot of queries that\\ndoesn't handle CANCEL well ~ doesn't handle interrupt well, and this can be\\nunfriendly. Cannot to say if it is good enough for first iteration. This is\\nfunctionality that can be used for diagnostic when you have overloaded\\nserver and this risk looks too high (for me). The idea of receive slot can\\nto solve this risk well (and can be used elsewhere). The difference from\\nthis code should not be too big - although it is not trivial - needs work\\nwith PGPROC. The opinion of our multiprocess experts can be interesting.\\nMaybe I am too careful.\\n\\nSorry, but I still don't see how the slots help this issue - could you\\nplease elaborate?\\n\\n>> Other smaller issues:\\n>>\\n>> * probably sending line by line is useless - shm_mq_send can pass bigger\\ndata when nowait = false\\n\\nI'm not sending it like that because of the message size - I just find it\\nmore convenient. If you think it can be problematic, its easy to do this as\\nbefore, by splitting lines on the receiving side.\\n\\n>> * pg_usleep(1000L); - it is related to single point resource\\n\\nBut not a highly concurrent one.\\n\\n-\\nAlex\\n\\nOn Sep 3, 2015 10:14 PM, \\\"Pavel Stehule\\\" <pavel.stehule@gmail.com> wrote:\\n>>>\\n>>> Please find attached a v3.\\n>>>\\n>>> It uses a shared memory queue and also has the ability to capture plans nested deeply in the call stack. Not sure about using the executor hook, since this is not an extension...\\n>>>\\n>>> The LWLock is used around initializing/cleaning the shared struct and the message queue, the IO synchronization is handled by the message queue itself.\\n>>\\n>> I am not pretty happy from this design. Only one EXPLAIN PID/GET STATUS in one time can be executed per server - I remember lot of queries that doesn't handle CANCEL well ~ doesn't handle interrupt well, and this can be unfriendly. Cannot to say if it is good enough for first iteration. This is functionality that can be used for diagnostic when you have overloaded server and this risk looks too high (for me). The idea of receive slot can to solve this risk well (and can be used elsewhere). The difference from this code should not be too big - although it is not trivial - needs work with PGPROC. The opinion of our multiprocess experts can be interesting. Maybe I am too careful.\\nSorry, but I still don't see how the slots help this issue - could you please elaborate?\\n>> Other smaller issues:\\n>>\\n>> * probably sending line by line is useless - shm_mq_send can pass bigger data when nowait = false\\nI'm not sending it like that because of the message size - I just find it more convenient. If you think it can be problematic, its easy to do this as before, by splitting lines on the receiving side.\\n>> * pg_usleep(1000L); - it is related to single point resource\\nBut not a highly concurrent one.\\n-\\nAlex\",\n \"msg_date\": \"Fri, 4 Sep 2015 05:50:33 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-04 5:50 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:\\n\\n> On Sep 3, 2015 10:14 PM, \\\"Pavel Stehule\\\" <pavel.stehule@gmail.com> wrote:\\n> >>>\\n> >>> Please find attached a v3.\\n> >>>\\n> >>> It uses a shared memory queue and also has the ability to capture\\n> plans nested deeply in the call stack. Not sure about using the executor\\n> hook, since this is not an extension...\\n> >>>\\n> >>> The LWLock is used around initializing/cleaning the shared struct and\\n> the message queue, the IO synchronization is handled by the message queue\\n> itself.\\n> >>\\n> >> I am not pretty happy from this design. Only one EXPLAIN PID/GET STATUS\\n> in one time can be executed per server - I remember lot of queries that\\n> doesn't handle CANCEL well ~ doesn't handle interrupt well, and this can be\\n> unfriendly. Cannot to say if it is good enough for first iteration. This is\\n> functionality that can be used for diagnostic when you have overloaded\\n> server and this risk looks too high (for me). The idea of receive slot can\\n> to solve this risk well (and can be used elsewhere). The difference from\\n> this code should not be too big - although it is not trivial - needs work\\n> with PGPROC. The opinion of our multiprocess experts can be interesting.\\n> Maybe I am too careful.\\n>\\n> Sorry, but I still don't see how the slots help this issue - could you\\n> please elaborate?\\n>\\nwith slot (or some similiar) there is not global locked resource. If I'll\\nhave a time at weekend I'll try to write some prototype.\\n\\n\\n> >> Other smaller issues:\\n> >>\\n> >> * probably sending line by line is useless - shm_mq_send can pass\\n> bigger data when nowait = false\\n>\\n> I'm not sending it like that because of the message size - I just find it\\n> more convenient. If you think it can be problematic, its easy to do this as\\n> before, by splitting lines on the receiving side.\\n>\\nYes, shm queue sending data immediately - so slicing on sender generates\\nmore interprocess communication\\n\\n\\n> >> * pg_usleep(1000L); - it is related to single point resource\\n>\\n> But not a highly concurrent one.\\n>\\nI believe so it is not becessary - waiting (sleeping) can be deeper in\\nreading from queue - the code will be cleaner\\n\\nRegard\\n\\nPavel\\n\\n\\n> -\\n> Alex\\n>\\n\\n2015-09-04 5:50 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Sep 3, 2015 10:14 PM, \\\"Pavel Stehule\\\" <pavel.stehule@gmail.com> wrote:\\n>>>\\n>>> Please find attached a v3.\\n>>>\\n>>> It uses a shared memory queue and also has the ability to capture plans nested deeply in the call stack. Not sure about using the executor hook, since this is not an extension...\\n>>>\\n>>> The LWLock is used around initializing/cleaning the shared struct and the message queue, the IO synchronization is handled by the message queue itself.\\n>>\\n>> I am not pretty happy from this design. Only one EXPLAIN PID/GET STATUS in one time can be executed per server - I remember lot of queries that doesn't handle CANCEL well ~ doesn't handle interrupt well, and this can be unfriendly. Cannot to say if it is good enough for first iteration. This is functionality that can be used for diagnostic when you have overloaded server and this risk looks too high (for me). The idea of receive slot can to solve this risk well (and can be used elsewhere). The difference from this code should not be too big - although it is not trivial - needs work with PGPROC. The opinion of our multiprocess experts can be interesting. Maybe I am too careful.\\nSorry, but I still don't see how the slots help this issue - could you please elaborate?with slot (or some similiar) there is not global locked resource. If I'll have a time at weekend I'll try to write some prototype. \\n>> Other smaller issues:\\n>>\\n>> * probably sending line by line is useless - shm_mq_send can pass bigger data when nowait = false\\nI'm not sending it like that because of the message size - I just find it more convenient. If you think it can be problematic, its easy to do this as before, by splitting lines on the receiving side.Yes, shm queue sending data immediately - so slicing on sender generates more interprocess communication \\n>> * pg_usleep(1000L); - it is related to single point resource\\nBut not a highly concurrent one.I believe so it is not becessary - waiting (sleeping) can be deeper in reading from queue - the code will be cleanerRegardPavel \\n-\\nAlex\",\n \"msg_date\": \"Fri, 4 Sep 2015 06:11:37 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 4, 2015 at 6:11 AM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n\\n> Sorry, but I still don't see how the slots help this issue - could you\\n>> please elaborate?\\n>>\\n> with slot (or some similiar) there is not global locked resource. If I'll\\n> have a time at weekend I'll try to write some prototype.\\n>\\n\\nBut you will still lock on the slots list to find an unused one. How is\\nthat substantially different from what I'm doing?\\n\\n> >> Other smaller issues:\\n>> >>\\n>> >> * probably sending line by line is useless - shm_mq_send can pass\\n>> bigger data when nowait = false\\n>>\\n>> I'm not sending it like that because of the message size - I just find it\\n>> more convenient. If you think it can be problematic, its easy to do this as\\n>> before, by splitting lines on the receiving side.\\n>>\\n> Yes, shm queue sending data immediately - so slicing on sender generates\\n> more interprocess communication\\n>\\n\\nWell, we are talking about hundreds to thousands bytes per plan in total.\\nAnd if my reading of shm_mq implementation is correct, if the message fits\\ninto the shared memory buffer, the receiver gets the direct pointer to the\\nshared memory, no extra allocation/copy to process-local memory. So this\\ncan be actually a win.\\n\\n> >> * pg_usleep(1000L); - it is related to single point resource\\n>>\\n>> But not a highly concurrent one.\\n>>\\n> I believe so it is not becessary - waiting (sleeping) can be deeper in\\n> reading from queue - the code will be cleaner\\n>\\n\\nThe only way I expect this line to be reached is when a concurrent\\npg_cmdstatus() call is in progress: the receiving backend has set the\\ntarget_pid and has created the queue, released the lock and now waits to\\nread something from shm_mq. So the backend that's trying to also use this\\ncommunication channel can obtain the lwlock, checks if the channel is not\\nused at the time, fails and then it needs to check again, but that's going\\nto put a load on the CPU, so there's a small sleep.\\n\\nThe real problem could be if the process that was signaled to connect to\\nthe message queue never handles the interrupt, and we keep waiting forever\\nin shm_mq_receive(). We could add a timeout parameter or just let the user\\ncancel the call: send a cancellation request, use pg_cancel_backend() or\\nset statement_timeout before running this.\\n\\n--\\nAlex\\n\\nOn Fri, Sep 4, 2015 at 6:11 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:Sorry, but I still don't see how the slots help this issue - could you please elaborate?with slot (or some similiar) there is not global locked resource. If I'll have a time at weekend I'll try to write some prototype.But you will still lock on the slots list to find an unused one. How is that substantially different from what I'm doing?\\n>> Other smaller issues:\\n>>\\n>> * probably sending line by line is useless - shm_mq_send can pass bigger data when nowait = false\\nI'm not sending it like that because of the message size - I just find it more convenient. If you think it can be problematic, its easy to do this as before, by splitting lines on the receiving side.Yes, shm queue sending data immediately - so slicing on sender generates more interprocess communication Well, we are talking about hundreds to thousands bytes per plan in total. And if my reading of shm_mq implementation is correct, if the message fits into the shared memory buffer, the receiver gets the direct pointer to the shared memory, no extra allocation/copy to process-local memory. So this can be actually a win.\\n>> * pg_usleep(1000L); - it is related to single point resource\\nBut not a highly concurrent one.I believe so it is not becessary - waiting (sleeping) can be deeper in reading from queue - the code will be cleanerThe only way I expect this line to be reached is when a concurrent pg_cmdstatus() call is in progress: the receiving backend has set the target_pid and has created the queue, released the lock and now waits to read something from shm_mq. So the backend that's trying to also use this communication channel can obtain the lwlock, checks if the channel is not used at the time, fails and then it needs to check again, but that's going to put a load on the CPU, so there's a small sleep.The real problem could be if the process that was signaled to connect to the message queue never handles the interrupt, and we keep waiting forever in shm_mq_receive(). We could add a timeout parameter or just let the user cancel the call: send a cancellation request, use pg_cancel_backend() or set statement_timeout before running this.--Alex\",\n \"msg_date\": \"Mon, 7 Sep 2015 11:55:23 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-07 11:55 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Fri, Sep 4, 2015 at 6:11 AM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n>\\n>> Sorry, but I still don't see how the slots help this issue - could you\\n>>> please elaborate?\\n>>>\\n>> with slot (or some similiar) there is not global locked resource. If I'll\\n>> have a time at weekend I'll try to write some prototype.\\n>>\\n>\\n> But you will still lock on the slots list to find an unused one. How is\\n> that substantially different from what I'm doing?\\n>\\n\\nIt is not necessary - you can use similar technique to what it does PGPROC.\\nI am sending \\\"lock free\\\" demo.\\n\\nI don't afraid about locks - short locks, when the range and time are\\nlimited. But there are lot of bugs, and fixes with the name \\\"do\\ninterruptible some\\\", and it is reason, why I prefer typical design for work\\nwith shared memory.\\n\\n\\n> >> Other smaller issues:\\n>>> >>\\n>>> >> * probably sending line by line is useless - shm_mq_send can pass\\n>>> bigger data when nowait = false\\n>>>\\n>>> I'm not sending it like that because of the message size - I just find\\n>>> it more convenient. If you think it can be problematic, its easy to do this\\n>>> as before, by splitting lines on the receiving side.\\n>>>\\n>> Yes, shm queue sending data immediately - so slicing on sender generates\\n>> more interprocess communication\\n>>\\n>\\n> Well, we are talking about hundreds to thousands bytes per plan in total.\\n> And if my reading of shm_mq implementation is correct, if the message fits\\n> into the shared memory buffer, the receiver gets the direct pointer to the\\n> shared memory, no extra allocation/copy to process-local memory. So this\\n> can be actually a win.\\n>\\n\\nyou have to calculate with signals and interprocess communication. the cost\\nof memory allocation is not all.\\n\\n> >> * pg_usleep(1000L); - it is related to single point resource\\n>>>\\n>>> But not a highly concurrent one.\\n>>>\\n>> I believe so it is not becessary - waiting (sleeping) can be deeper in\\n>> reading from queue - the code will be cleaner\\n>>\\n>\\n> The only way I expect this line to be reached is when a concurrent\\n> pg_cmdstatus() call is in progress: the receiving backend has set the\\n> target_pid and has created the queue, released the lock and now waits to\\n> read something from shm_mq. So the backend that's trying to also use this\\n> communication channel can obtain the lwlock, checks if the channel is not\\n> used at the time, fails and then it needs to check again, but that's going\\n> to put a load on the CPU, so there's a small sleep.\\n>\\n> The real problem could be if the process that was signaled to connect to\\n> the message queue never handles the interrupt, and we keep waiting forever\\n> in shm_mq_receive(). We could add a timeout parameter or just let the user\\n> cancel the call: send a cancellation request, use pg_cancel_backend() or\\n> set statement_timeout before running this.\\n>\\n\\nThis is valid question - for begin we can use a statement_timeout and we\\ndon't need to design some special (if you don't hold some important lock).\\n\\nMy example (the code has prototype quality) is little bit longer, but it\\nwork without global lock - the requester doesn't block any other\\n\\nPavel\\n\\n\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 8 Sep 2015 06:58:37 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 8, 2015 at 6:58 AM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n>>\\n>> But you will still lock on the slots list to find an unused one. How is\\nthat substantially different from what I'm doing?\\n>\\n> It is not necessary - you can use similar technique to what it does\\nPGPROC. I am sending \\\"lock free\\\" demo.\\n>\\n> I don't afraid about locks - short locks, when the range and time are\\nlimited. But there are lot of bugs, and fixes with the name \\\"do\\ninterruptible some\\\", and it is reason, why I prefer typical design for work\\nwith shared memory.\\n\\nThanks, this is really helpful! The key difference is that every backend\\nhas a dedicated slot, so there's no need to search for a free one, which\\nwould again incur locking.\\n\\n>> Well, we are talking about hundreds to thousands bytes per plan in\\ntotal. And if my reading of shm_mq implementation is correct, if the\\nmessage fits into the shared memory buffer, the receiver gets the direct\\npointer to the shared memory, no extra allocation/copy to process-local\\nmemory. So this can be actually a win.\\n>\\n> you have to calculate with signals and interprocess communication. the\\ncost of memory allocation is not all.\\n\\nSure. Anyway, we're talking about only kilobytes being sent in this case,\\nso the whole performance discussion is rather moot.\\n\\n>> The real problem could be if the process that was signaled to connect to\\nthe message queue never handles the interrupt, and we keep waiting forever\\nin shm_mq_receive(). We could add a timeout parameter or just let the user\\ncancel the call: send a cancellation request, use pg_cancel_backend() or\\nset statement_timeout before running this.\\n>\\n> This is valid question - for begin we can use a statement_timeout and we\\ndon't need to design some special (if you don't hold some important lock).\\n> My example (the code has prototype quality) is little bit longer, but it\\nwork without global lock - the requester doesn't block any other\\n\\nI'll update the commitfest patch to use this technique.\\n\\n--\\nAlex\\n\\nOn Tue, Sep 8, 2015 at 6:58 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:>>>> But you will still lock on the slots list to find an unused one. How is that substantially different from what I'm doing?>> It is not necessary - you can use similar technique to what it does PGPROC. I am sending \\\"lock free\\\" demo.>> I don't afraid about locks - short locks, when the range and time are limited. But there are lot of bugs, and fixes with the name \\\"do interruptible some\\\", and it is reason, why I prefer typical design for work with shared memory. Thanks, this is really helpful! The key difference is that every backend has a dedicated slot, so there's no need to search for a free one, which would again incur locking.>> Well, we are talking about hundreds to thousands bytes per plan in total. And if my reading of shm_mq implementation is correct, if the message fits into the shared memory buffer, the receiver gets the direct pointer to the shared memory, no extra allocation/copy to process-local memory. So this can be actually a win.>> you have to calculate with signals and interprocess communication. the cost of memory allocation is not all.Sure. Anyway, we're talking about only kilobytes being sent in this case, so the whole performance discussion is rather moot.>> The real problem could be if the process that was signaled to connect to the message queue never handles the interrupt, and we keep waiting forever in shm_mq_receive(). We could add a timeout parameter or just let the user cancel the call: send a cancellation request, use pg_cancel_backend() or set statement_timeout before running this.> > This is valid question - for begin we can use a statement_timeout and we don't need to design some special (if you don't hold some important lock).> My example (the code has prototype quality) is little bit longer, but it work without global lock - the requester doesn't block any otherI'll update the commitfest patch to use this technique.--Alex\",\n \"msg_date\": \"Tue, 8 Sep 2015 11:49:36 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 8, 2015 at 11:49 AM, Shulgin, Oleksandr <\\noleksandr.shulgin@zalando.de> wrote:\\n\\n>\\n> >> The real problem could be if the process that was signaled to connect\\n> to the message queue never handles the interrupt, and we keep waiting\\n> forever in shm_mq_receive(). We could add a timeout parameter or just let\\n> the user cancel the call: send a cancellation request, use\\n> pg_cancel_backend() or set statement_timeout before running this.\\n> >\\n> > This is valid question - for begin we can use a statement_timeout and we\\n> don't need to design some special (if you don't hold some important lock).\\n> > My example (the code has prototype quality) is little bit longer, but it\\n> work without global lock - the requester doesn't block any other\\n>\\n> I'll update the commitfest patch to use this technique.\\n>\\n\\nPlease find attached v4.\\n\\n--\\nAlex\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 8 Sep 2015 18:53:52 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-08 18:53 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Tue, Sep 8, 2015 at 11:49 AM, Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de> wrote:\\n>\\n>>\\n>> >> The real problem could be if the process that was signaled to connect\\n>> to the message queue never handles the interrupt, and we keep waiting\\n>> forever in shm_mq_receive(). We could add a timeout parameter or just let\\n>> the user cancel the call: send a cancellation request, use\\n>> pg_cancel_backend() or set statement_timeout before running this.\\n>> >\\n>> > This is valid question - for begin we can use a statement_timeout and\\n>> we don't need to design some special (if you don't hold some important\\n>> lock).\\n>> > My example (the code has prototype quality) is little bit longer, but\\n>> it work without global lock - the requester doesn't block any other\\n>>\\n>> I'll update the commitfest patch to use this technique.\\n>>\\n>\\n> Please find attached v4.\\n>\\n\\nIt is better\\n\\nTwo notices:\\n\\n1. The communication mechanism can be used more wide, than only for this\\npurpose. We can introduce a SendInfoHook - and it can be used for any\\ncustomer probes - memory, cpu, ...\\n\\n2. With your support for explain of nested queries we have all what we need\\nfor integration auto_explain to core.\\n\\nRegards\\n\\nPavel\\n\\n\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n2015-09-08 18:53 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Tue, Sep 8, 2015 at 11:49 AM, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote:>> The real problem could be if the process that was signaled to connect to the message queue never handles the interrupt, and we keep waiting forever in shm_mq_receive(). We could add a timeout parameter or just let the user cancel the call: send a cancellation request, use pg_cancel_backend() or set statement_timeout before running this.> > This is valid question - for begin we can use a statement_timeout and we don't need to design some special (if you don't hold some important lock).> My example (the code has prototype quality) is little bit longer, but it work without global lock - the requester doesn't block any otherI'll update the commitfest patch to use this technique.Please find attached v4.It is betterTwo notices:1. The communication mechanism can be used more wide, than only for this purpose. We can introduce a SendInfoHook - and it can be used for any customer probes - memory, cpu, ...2. With your support for explain of nested queries we have all what we need for integration auto_explain to core. RegardsPavel --Alex\",\n \"msg_date\": \"Wed, 9 Sep 2015 08:36:33 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 9, 2015 at 8:36 AM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n\\n>\\n>> Please find attached v4.\\n>>\\n>\\n> It is better\\n>\\n\\nOne important thing to notice, and probably deserves a code comment, that\\nany modification of the slot fields done by the info sender backend must be\\ndone before actually sending the message via the shared memory queue (or\\ndetaching one, if there's nothing to be sent). Otherwise it is possible\\nthat is_processed flag will be set on the slot that has been already reused\\nby the receiving backend.\\n\\nI could hit that problem rather easily while doing\\n\\nselect pg_cmdstatus(pid,$1) from pg_stat_activity where\\npid<>pg_backend_pid() \\\\watch 1\\n\\nand running pgbench with >= 8 connections in the background. The observed\\neffect is that after a few successful runs, the pg_cmdstatus() never\\nreturns because the next signaled backend loops through the slots and\\ndoesn't find an unprocessed one (because it was marked as processed by the\\nbackend that was responding just before it).\\n\\nTwo notices:\\n>\\n> 1. The communication mechanism can be used more wide, than only for this\\n> purpose. We can introduce a SendInfoHook - and it can be used for any\\n> customer probes - memory, cpu, ...\\n>\\n\\nNot sure if for CPU you can get any more insight than an external tool like\\ntop(1) will provide. For the memory, it might be indeed useful in some way\\n(memory context inspection?)\\n\\nSo there's certainly a space for generalization. Rename it as\\npg_backend_info()?\\n\\n2. With your support for explain of nested queries we have all what we need\\n> for integration auto_explain to core.\\n>\\n\\nWell, I don't quite see how that follows. What I'm really after is\\nbringing instrumentation support to this, so that not only plan could be\\nextracted, but also the rows/loops/times accumulated thus far during the\\nquery run.\\n\\n--\\nAlex\\n\\nOn Wed, Sep 9, 2015 at 8:36 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:Please find attached v4.It is betterOne important thing to notice, and probably deserves a code comment, that any modification of the slot fields done by the info sender backend must be done before actually sending the message via the shared memory queue (or detaching one, if there's nothing to be sent). Otherwise it is possible that is_processed flag will be set on the slot that has been already reused by the receiving backend.I could hit that problem rather easily while doingselect pg_cmdstatus(pid,$1) from pg_stat_activity where pid<>pg_backend_pid() \\\\watch 1and running pgbench with >= 8 connections in the background. The observed effect is that after a few successful runs, the pg_cmdstatus() never returns because the next signaled backend loops through the slots and doesn't find an unprocessed one (because it was marked as processed by the backend that was responding just before it).Two notices:1. The communication mechanism can be used more wide, than only for this purpose. We can introduce a SendInfoHook - and it can be used for any customer probes - memory, cpu, ...Not sure if for CPU you can get any more insight than an external tool like top(1) will provide. For the memory, it might be indeed useful in some way (memory context inspection?)So there's certainly a space for generalization. Rename it as pg_backend_info()?2. With your support for explain of nested queries we have all what we need for integration auto_explain to core. Well, I don't quite see how that follows. What I'm really after is bringing instrumentation support to this, so that not only plan could be extracted, but also the rows/loops/times accumulated thus far during the query run.--Alex\",\n \"msg_date\": \"Wed, 9 Sep 2015 10:22:02 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"Two notices:\\n>\\n> 1. The communication mechanism can be used more wide, than only for this\\n> purpose. We can introduce a SendInfoHook - and it can be used for any\\n> customer probes - memory, cpu, ...\\n>\\n\\nNot sure if for CPU you can get any more insight than an external tool like\\ntop(1) will provide. For the memory, it might be indeed useful in some way\\n(memory context inspection?)\\n\\nCPU is probably nonsense - sorry - but there are more other possibilities,\\nhow to use it - simple checking some internal states of extensions without\\nlog processing or without gdb, etc\\n\\n\\n>\\n> So there's certainly a space for generalization. Rename it as\\n> pg_backend_info()?\\n>\\n\\nIt is good name, so why not?\\n\\n>\\n> 2. With your support for explain of nested queries we have all what we\\n>> need for integration auto_explain to core.\\n>>\\n>\\n> Well, I don't quite see how that follows. What I'm really after is\\n> bringing instrumentation support to this, so that not only plan could be\\n> extracted, but also the rows/loops/times accumulated thus far during the\\n> query run.\\n>\\n\\nIt is possible, but not necessary step - but it is premature question in\\nthis moment\\n\\nRegards\\n\\nPavel\\n\\n\\n>\\n> --\\n> Alex\\n>\\n>\\n\\nTwo notices:1. The communication mechanism can be used more wide, than only for this purpose. We can introduce a SendInfoHook - and it can be used for any customer probes - memory, cpu, ...Not sure if for CPU you can get any more insight than an external tool like top(1) will provide. For the memory, it might be indeed useful in some way (memory context inspection?)CPU is probably nonsense - sorry - but there are more other possibilities, how to use it - simple checking some internal states of extensions without log processing or without gdb, etc So there's certainly a space for generalization. Rename it as pg_backend_info()?It is good name, so why not? 2. With your support for explain of nested queries we have all what we need for integration auto_explain to core. Well, I don't quite see how that follows. What I'm really after is bringing instrumentation support to this, so that not only plan could be extracted, but also the rows/loops/times accumulated thus far during the query run.It is possible, but not necessary step - but it is premature question in this momentRegardsPavel --Alex\",\n \"msg_date\": \"Wed, 9 Sep 2015 10:46:52 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 9, 2015 at 10:22 AM, Shulgin, Oleksandr <\\noleksandr.shulgin@zalando.de> wrote:\\n\\n> On Wed, Sep 9, 2015 at 8:36 AM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n>\\n>>\\n>>> Please find attached v4.\\n>>>\\n>>\\n>> It is better\\n>>\\n>\\n> One important thing to notice, and probably deserves a code comment, that\\n> any modification of the slot fields done by the info sender backend must be\\n> done before actually sending the message via the shared memory queue (or\\n> detaching one, if there's nothing to be sent). Otherwise it is possible\\n> that is_processed flag will be set on the slot that has been already reused\\n> by the receiving backend.\\n>\\n\\nSorry, the latest version did contain some debugging messages I didn't\\nintend to send. I've removed them and also added a comment about the above\\nsynchronization problem.\\n\\n--\\nAlex\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Wed, 9 Sep 2015 11:54:44 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nI did a quick initial review of this patch today, so here are my \\ncomments so far:\\n\\n- ipcs.c should include utils/cmdstatus.h (the compiler complains\\n about implicit declaration of two functions)\\n\\n- Attempts to get plan for simple insert queries like this\\n\\n INSERT INTO x SELECT * FROM x;\\n\\n end with a segfault, because ActivePortal->queryDesc is 0x0 for this\\n query. Needs investigation.\\n\\n- The lockless approach seems fine to me, although I think the fear\\n of performance issues is a bit moot (I don't think we expect large\\n number of processes calling pg_cmdstatus at the same time). But\\n it's not significantly more complex, so why not.\\n\\n- The patch contains pretty much no documentation, both comments\\n at the code level and user docs. The lack of user docs is not that\\n a big deal at this point (although the patch seems to be mature\\n enough, although the user-level API will likely change).\\n\\n The lack of code comments is more serious, as it makes the review\\n somewhat more difficult. For example it'd be very nice to document\\n the contract for the lock-less interface.\\n\\n- I agree that pg_cmdstatus() is not the best API. Having something\\n like EXPLAIN PID would be nice, but it does not really work for\\n all the request types (just CMD_STATUS_REQUEST_EXPLAIN). Maybe\\n there's not a single API for all cases, i.e. we should use EXPLAIN\\n PID for one case and invent something different for the other?\\n\\n- Is there a particular reason why we allocate slots for auxiliary\\n processes and not just for backends (NumBackends)? Do we expect those\\n auxiliary processes to ever use this API?\\n\\n- CleanupCmdStatusSlot seems needlessly complicated. I don't quite see\\n the need for the second argument, or the internal slot variable. Why\\n not to simply use the MyCmdStatusSlot directly?\\n\\n- I also don't quite understand why we need to track css_pid for the\\n slot? In what scenario will this actually matter?\\n\\n- While being able to get EXPLAIN from the running process is nice,\\n I'm especially interested in getting EXPLAIN ANALYZE to get insight\\n into the progress of the execution. The are other ways to get the\\n EXPLAIN, e.g. by opening a different connection and actually running\\n it (sure, the plan might have changed since then), but currently\\n there's no way to get insight into the progress.\\n\\n From the thread I get the impression that Oleksandr also finds this\\n useful - correct? What are the plans in this direction?\\n\\n ISTM we need at least two things for that to work:\\n\\n (a) Ability to enable instrumentation on all queries (effectively\\n what auto_explain allows), otherwise we can't get EXPLAIN ANALYZE\\n on the queries later. But auto_explain is an extension, so that\\n does not seem as a good match if this is supposed to be in core.\\n In that case a separate GUC seems appropriate.\\n\\n (b) Being able to run the InstrEnd* methods repeatedly - the initial\\n message in this thread mentions issues with InstrEndLoop for\\n example. So perhaps this is non-trivial.\\n\\n- And finally, I think we should really support all existing EXPLAIN\\n formats, not just text. We need to support the other formats (yaml,\\n json, xml) if we want to use the EXPLAIN PID approach, and it also\\n makes the plans easier to process by additional tools.\\n\\n\\nregards\\n\\n-- \\nTomas Vondra http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 12 Sep 2015 11:50:36 +0200\",\n \"msg_from\": \"Tomas Vondra <tomas.vondra@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and\\n signals\"\n },\n {\n \"msg_contents\": \"Hi\\n\\nThank you for precious check.\\n\\n2015-09-12 11:50 GMT+02:00 Tomas Vondra <tomas.vondra@2ndquadrant.com>:\\n\\n> Hi,\\n>\\n> I did a quick initial review of this patch today, so here are my comments\\n> so far:\\n>\\n> - ipcs.c should include utils/cmdstatus.h (the compiler complains\\n> about implicit declaration of two functions)\\n>\\n> - Attempts to get plan for simple insert queries like this\\n>\\n> INSERT INTO x SELECT * FROM x;\\n>\\n> end with a segfault, because ActivePortal->queryDesc is 0x0 for this\\n> query. Needs investigation.\\n>\\n> - The lockless approach seems fine to me, although I think the fear\\n> of performance issues is a bit moot (I don't think we expect large\\n> number of processes calling pg_cmdstatus at the same time). But\\n> it's not significantly more complex, so why not.\\n>\\n> - The patch contains pretty much no documentation, both comments\\n> at the code level and user docs. The lack of user docs is not that\\n> a big deal at this point (although the patch seems to be mature\\n> enough, although the user-level API will likely change).\\n>\\n> The lack of code comments is more serious, as it makes the review\\n> somewhat more difficult. For example it'd be very nice to document\\n> the contract for the lock-less interface.\\n>\\n> - I agree that pg_cmdstatus() is not the best API. Having something\\n> like EXPLAIN PID would be nice, but it does not really work for\\n> all the request types (just CMD_STATUS_REQUEST_EXPLAIN). Maybe\\n> there's not a single API for all cases, i.e. we should use EXPLAIN\\n> PID for one case and invent something different for the other?\\n>\\n\\nI used this simple interface because it is faster way how to get a\\nprototype. In this patch the most complexity is in interprocess\\ncommunication and in executor hooking. The UI can be designed later very\\nquickly.\\n\\nThere is consensus about EXPLAIN PID, for other (status, query) I don't\\nwant to introduce new keyword, so there will be accessed via functions. But\\nwe can introduce psql commands\\n\\n\\\\qpid - query pid and \\\\spid - status pid\\n\\n\\n> - Is there a particular reason why we allocate slots for auxiliary\\n> processes and not just for backends (NumBackends)? Do we expect those\\n> auxiliary processes to ever use this API?\\n>\\n\\nThe introduced interprocess communication (we talked about this possibility\\nweek ago) can be used by any diagnostic extension - so aux processes can be\\ninteresting too.\\n\\n\\n>\\n> - CleanupCmdStatusSlot seems needlessly complicated. I don't quite see\\n> the need for the second argument, or the internal slot variable. Why\\n> not to simply use the MyCmdStatusSlot directly?\\n>\\n> - I also don't quite understand why we need to track css_pid for the\\n> slot? In what scenario will this actually matter?\\n>\\n>\\nI have to recheck it - but this is safeguard against to change process with\\nsame backendId.\\n\\n\\n> - While being able to get EXPLAIN from the running process is nice,\\n> I'm especially interested in getting EXPLAIN ANALYZE to get insight\\n> into the progress of the execution. The are other ways to get the\\n> EXPLAIN, e.g. by opening a different connection and actually running\\n> it (sure, the plan might have changed since then), but currently\\n> there's no way to get insight into the progress.\\n>\\n\\nIt can be pretty nice feature. I though about it - as next step of this\\nfeature. But I have not idea how it is complex task - maybe not too much.\\n\\n\\n>\\n> From the thread I get the impression that Oleksandr also finds this\\n> useful - correct? What are the plans in this direction?\\n>\\n> ISTM we need at least two things for that to work:\\n>\\n> (a) Ability to enable instrumentation on all queries (effectively\\n> what auto_explain allows), otherwise we can't get EXPLAIN ANALYZE\\n> on the queries later. But auto_explain is an extension, so that\\n> does not seem as a good match if this is supposed to be in core.\\n> In that case a separate GUC seems appropriate.\\n>\\n\\nIf described functionality will be implemented, then auto_explain extension\\nwill be very thin envelop - I don't see any reason, why it should not be\\nintegrated to core.\\n\\n\\n>\\n> (b) Being able to run the InstrEnd* methods repeatedly - the initial\\n> message in this thread mentions issues with InstrEndLoop for\\n> example. So perhaps this is non-trivial.\\n>\\n> - And finally, I think we should really support all existing EXPLAIN\\n> formats, not just text. We need to support the other formats (yaml,\\n> json, xml) if we want to use the EXPLAIN PID approach, and it also\\n> makes the plans easier to process by additional tools.\\n>\\n\\nsurely - there is not any reason why not.\\n\\nRegards\\n\\nPavel\\n\\n\\n>\\n>\\n> regards\\n>\\n> --\\n> Tomas Vondra http://www.2ndQuadrant.com/\\n> PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n>\\n>\\n> --\\n> Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\n> To make changes to your subscription:\\n> http://www.postgresql.org/mailpref/pgsql-hackers\\n>\\n\\nHiThank you for precious check.2015-09-12 11:50 GMT+02:00 Tomas Vondra <tomas.vondra@2ndquadrant.com>:Hi,\\n\\nI did a quick initial review of this patch today, so here are my comments so far:\\n\\n- ipcs.c should include utils/cmdstatus.h (the compiler complains\\n about implicit declaration of two functions)\\n\\n- Attempts to get plan for simple insert queries like this\\n\\n INSERT INTO x SELECT * FROM x;\\n\\n end with a segfault, because ActivePortal->queryDesc is 0x0 for this\\n query. Needs investigation.\\n\\n- The lockless approach seems fine to me, although I think the fear\\n of performance issues is a bit moot (I don't think we expect large\\n number of processes calling pg_cmdstatus at the same time). But\\n it's not significantly more complex, so why not.\\n\\n- The patch contains pretty much no documentation, both comments\\n at the code level and user docs. The lack of user docs is not that\\n a big deal at this point (although the patch seems to be mature\\n enough, although the user-level API will likely change).\\n\\n The lack of code comments is more serious, as it makes the review\\n somewhat more difficult. For example it'd be very nice to document\\n the contract for the lock-less interface.\\n\\n- I agree that pg_cmdstatus() is not the best API. Having something\\n like EXPLAIN PID would be nice, but it does not really work for\\n all the request types (just CMD_STATUS_REQUEST_EXPLAIN). Maybe\\n there's not a single API for all cases, i.e. we should use EXPLAIN\\n PID for one case and invent something different for the other?I used this simple interface because it is faster way how to get a prototype. In this patch the most complexity is in interprocess communication and in executor hooking. The UI can be designed later very quickly. There is consensus about EXPLAIN PID, for other (status, query) I don't want to introduce new keyword, so there will be accessed via functions. But we can introduce psql commands\\\\qpid - query pid and \\\\spid - status pid\\n\\n- Is there a particular reason why we allocate slots for auxiliary\\n processes and not just for backends (NumBackends)? Do we expect those\\n auxiliary processes to ever use this API?The introduced interprocess communication (we talked about this possibility week ago) can be used by any diagnostic extension - so aux processes can be interesting too. \\n\\n- CleanupCmdStatusSlot seems needlessly complicated. I don't quite see\\n the need for the second argument, or the internal slot variable. Why\\n not to simply use the MyCmdStatusSlot directly?\\n\\n- I also don't quite understand why we need to track css_pid for the\\n slot? In what scenario will this actually matter?\\nI have to recheck it - but this is safeguard against to change process with same backendId. \\n- While being able to get EXPLAIN from the running process is nice,\\n I'm especially interested in getting EXPLAIN ANALYZE to get insight\\n into the progress of the execution. The are other ways to get the\\n EXPLAIN, e.g. by opening a different connection and actually running\\n it (sure, the plan might have changed since then), but currently\\n there's no way to get insight into the progress.It can be pretty nice feature. I though about it - as next step of this feature. But I have not idea how it is complex task - maybe not too much. \\n\\n From the thread I get the impression that Oleksandr also finds this\\n useful - correct? What are the plans in this direction?\\n\\n ISTM we need at least two things for that to work:\\n\\n (a) Ability to enable instrumentation on all queries (effectively\\n what auto_explain allows), otherwise we can't get EXPLAIN ANALYZE\\n on the queries later. But auto_explain is an extension, so that\\n does not seem as a good match if this is supposed to be in core.\\n In that case a separate GUC seems appropriate.If described functionality will be implemented, then auto_explain extension will be very thin envelop - I don't see any reason, why it should not be integrated to core. \\n\\n (b) Being able to run the InstrEnd* methods repeatedly - the initial\\n message in this thread mentions issues with InstrEndLoop for\\n example. So perhaps this is non-trivial.\\n\\n- And finally, I think we should really support all existing EXPLAIN\\n formats, not just text. We need to support the other formats (yaml,\\n json, xml) if we want to use the EXPLAIN PID approach, and it also\\n makes the plans easier to process by additional tools.surely - there is not any reason why not.RegardsPavel \\n\\n\\nregards\\n\\n-- \\nTomas Vondra http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Sat, 12 Sep 2015 20:27:52 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Sat, Sep 12, 2015 at 11:50 AM, Tomas Vondra <tomas.vondra@2ndquadrant.com\\n> wrote:\\n\\n> Hi,\\n>\\n> I did a quick initial review of this patch today, so here are my comments\\n> so far:\\n>\\n\\nHi Tomas,\\n\\nFirst of all, thanks for the review!\\n\\n- ipcs.c should include utils/cmdstatus.h (the compiler complains\\n> about implicit declaration of two functions)\\n>\\n\\nCorrect, though the file name is ipci.c.\\n\\n- Attempts to get plan for simple insert queries like this\\n>\\n> INSERT INTO x SELECT * FROM x;\\n>\\n> end with a segfault, because ActivePortal->queryDesc is 0x0 for this\\n> query. Needs investigation.\\n>\\n\\nYes, I've hit the same problem after submitting the latest version of the\\npatch. For now I've just added a check for queryDesc being not NULL, but I\\nguess the top of the current_query_stack might contains something useful.\\nSomething I need to try.\\n\\n- The lockless approach seems fine to me, although I think the fear\\n> of performance issues is a bit moot (I don't think we expect large\\n> number of processes calling pg_cmdstatus at the same time). But\\n> it's not significantly more complex, so why not.\\n>\\n\\nI believe the main benefit of the less-locking approach is that if\\nsomething goes wrong when two backends tried to communicate it doesn't\\nprevent the rest of them from operating, because there is no shared (and\\nthus locked) communication channel.\\n\\n- The patch contains pretty much no documentation, both comments\\n> at the code level and user docs. The lack of user docs is not that\\n> a big deal at this point (although the patch seems to be mature\\n> enough, although the user-level API will likely change).\\n>\\n> The lack of code comments is more serious, as it makes the review\\n> somewhat more difficult. For example it'd be very nice to document\\n> the contract for the lock-less interface.\\n>\\n\\nI will add the code comments. The user docs could wait before we decide on\\nthe interface, I think.\\n\\n- I agree that pg_cmdstatus() is not the best API. Having something\\n> like EXPLAIN PID would be nice, but it does not really work for\\n> all the request types (just CMD_STATUS_REQUEST_EXPLAIN). Maybe\\n> there's not a single API for all cases, i.e. we should use EXPLAIN\\n> PID for one case and invent something different for the other?\\n>\\n\\nI can think of something like:\\n\\nEXPLAIN [ ( option [, ...] ) ] PROCESS <PID>;\\n\\nwhere option is extended with:\\n\\n QUERY\\n PROGRESS\\n BACKTRACE\\n\\nin addition to the usual ANALYZE, VERBOSE, FORMAT, etc.\\n\\n- Is there a particular reason why we allocate slots for auxiliary\\n> processes and not just for backends (NumBackends)? Do we expect those\\n> auxiliary processes to ever use this API?\\n>\\n\\nIf we extend the interface to a more general one, there still might be some\\nspace for querying status of checkpointer of bgwriter.\\n\\n- CleanupCmdStatusSlot seems needlessly complicated. I don't quite see\\n> the need for the second argument, or the internal slot variable. Why\\n> not to simply use the MyCmdStatusSlot directly?\\n>\\n\\nGood point.\\n\\n- I also don't quite understand why we need to track css_pid for the\\n> slot? In what scenario will this actually matter?\\n>\\n\\nI think it's being only used for error reporting and could help in\\ndebugging, but for now that's it.\\n\\n- While being able to get EXPLAIN from the running process is nice,\\n> I'm especially interested in getting EXPLAIN ANALYZE to get insight\\n> into the progress of the execution. The are other ways to get the\\n> EXPLAIN, e.g. by opening a different connection and actually running\\n> it (sure, the plan might have changed since then), but currently\\n> there's no way to get insight into the progress.\\n>\\n> From the thread I get the impression that Oleksandr also finds this\\n> useful - correct? What are the plans in this direction?\\n>\\n> ISTM we need at least two things for that to work:\\n>\\n> (a) Ability to enable instrumentation on all queries (effectively\\n> what auto_explain allows), otherwise we can't get EXPLAIN ANALYZE\\n> on the queries later. But auto_explain is an extension, so that\\n> does not seem as a good match if this is supposed to be in core.\\n> In that case a separate GUC seems appropriate.\\n>\\n> (b) Being able to run the InstrEnd* methods repeatedly - the initial\\n> message in this thread mentions issues with InstrEndLoop for\\n> example. So perhaps this is non-trivial.\\n>\\n\\nI was able to make this work with a simple change to InstrEndLoop and the\\ncallers. Basically, adding a bool parameter in_explain and passing an\\nappropriate value. I guess that's not the best approach, but it appears to\\nwork.\\n\\nAdding a GUC to enable instrumentation sounds reasonable.\\n\\nDo you believe it makes sense to add instrumentation support in this same\\npatch or better focus on making the simplest thing work first?\\n\\n- And finally, I think we should really support all existing EXPLAIN\\n> formats, not just text. We need to support the other formats (yaml,\\n> json, xml) if we want to use the EXPLAIN PID approach, and it also\\n> makes the plans easier to process by additional tools.\\n>\\n\\nSure, that was in my plans (and see above for possible syntax). What would\\nbe really neat is retrieving the complete backtrace. Not sure what the\\ngood interface would look like, but using JSON format for the output sounds\\npromising.\\n\\n--\\nAlex\\n\\nOn Sat, Sep 12, 2015 at 11:50 AM, Tomas Vondra <tomas.vondra@2ndquadrant.com> wrote:Hi,\\n\\nI did a quick initial review of this patch today, so here are my comments so far:Hi Tomas,First of all, thanks for the review!\\n- ipcs.c should include utils/cmdstatus.h (the compiler complains\\n about implicit declaration of two functions)Correct, though the file name is ipci.c.\\n- Attempts to get plan for simple insert queries like this\\n\\n INSERT INTO x SELECT * FROM x;\\n\\n end with a segfault, because ActivePortal->queryDesc is 0x0 for this\\n query. Needs investigation.Yes, I've hit the same problem after submitting the latest version of the patch. For now I've just added a check for queryDesc being not NULL, but I guess the top of the current_query_stack might contains something useful. Something I need to try.\\n- The lockless approach seems fine to me, although I think the fear\\n of performance issues is a bit moot (I don't think we expect large\\n number of processes calling pg_cmdstatus at the same time). But\\n it's not significantly more complex, so why not.I believe the main benefit of the less-locking approach is that if something goes wrong when two backends tried to communicate it doesn't prevent the rest of them from operating, because there is no shared (and thus locked) communication channel.\\n- The patch contains pretty much no documentation, both comments\\n at the code level and user docs. The lack of user docs is not that\\n a big deal at this point (although the patch seems to be mature\\n enough, although the user-level API will likely change).\\n\\n The lack of code comments is more serious, as it makes the review\\n somewhat more difficult. For example it'd be very nice to document\\n the contract for the lock-less interface.I will add the code comments. The user docs could wait before we decide on the interface, I think.\\n- I agree that pg_cmdstatus() is not the best API. Having something\\n like EXPLAIN PID would be nice, but it does not really work for\\n all the request types (just CMD_STATUS_REQUEST_EXPLAIN). Maybe\\n there's not a single API for all cases, i.e. we should use EXPLAIN\\n PID for one case and invent something different for the other?I can think of something like:EXPLAIN [ ( option [, ...] ) ] PROCESS <PID>;where option is extended with: QUERY PROGRESS BACKTRACEin addition to the usual ANALYZE, VERBOSE, FORMAT, etc.\\n- Is there a particular reason why we allocate slots for auxiliary\\n processes and not just for backends (NumBackends)? Do we expect those\\n auxiliary processes to ever use this API?If we extend the interface to a more general one, there still might be some space for querying status of checkpointer of bgwriter.\\n- CleanupCmdStatusSlot seems needlessly complicated. I don't quite see\\n the need for the second argument, or the internal slot variable. Why\\n not to simply use the MyCmdStatusSlot directly?Good point.\\n- I also don't quite understand why we need to track css_pid for the\\n slot? In what scenario will this actually matter?I think it's being only used for error reporting and could help in debugging, but for now that's it.\\n- While being able to get EXPLAIN from the running process is nice,\\n I'm especially interested in getting EXPLAIN ANALYZE to get insight\\n into the progress of the execution. The are other ways to get the\\n EXPLAIN, e.g. by opening a different connection and actually running\\n it (sure, the plan might have changed since then), but currently\\n there's no way to get insight into the progress.\\n\\n From the thread I get the impression that Oleksandr also finds this\\n useful - correct? What are the plans in this direction?\\n\\n ISTM we need at least two things for that to work:\\n\\n (a) Ability to enable instrumentation on all queries (effectively\\n what auto_explain allows), otherwise we can't get EXPLAIN ANALYZE\\n on the queries later. But auto_explain is an extension, so that\\n does not seem as a good match if this is supposed to be in core.\\n In that case a separate GUC seems appropriate.\\n\\n (b) Being able to run the InstrEnd* methods repeatedly - the initial\\n message in this thread mentions issues with InstrEndLoop for\\n example. So perhaps this is non-trivial.I was able to make this work with a simple change to InstrEndLoop and the callers. Basically, adding a bool parameter in_explain and passing an appropriate value. I guess that's not the best approach, but it appears to work.Adding a GUC to enable instrumentation sounds reasonable.Do you believe it makes sense to add instrumentation support in this same patch or better focus on making the simplest thing work first?\\n- And finally, I think we should really support all existing EXPLAIN\\n formats, not just text. We need to support the other formats (yaml,\\n json, xml) if we want to use the EXPLAIN PID approach, and it also\\n makes the plans easier to process by additional tools.Sure, that was in my plans (and see above for possible syntax). What would be really neat is retrieving the complete backtrace. Not sure what the good interface would look like, but using JSON format for the output sounds promising.--Alex\",\n \"msg_date\": \"Mon, 14 Sep 2015 10:23:48 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-14 10:23 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n>\\n>\\n>\\n> I can think of something like:\\n>\\n> EXPLAIN [ ( option [, ...] ) ] PROCESS <PID>;\\n>\\n> where option is extended with:\\n>\\n> QUERY\\n> PROGRESS\\n> BACKTRACE\\n>\\n> in addition to the usual ANALYZE, VERBOSE, FORMAT, etc.\\n>\\n>\\nIt can work\\n\\nRegards\\n\\nPavel\\n\\n2015-09-14 10:23 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:I can think of something like:EXPLAIN [ ( option [, ...] ) ] PROCESS <PID>;where option is extended with: QUERY PROGRESS BACKTRACEin addition to the usual ANALYZE, VERBOSE, FORMAT, etc.\\n\\nIt can workRegardsPavel\",\n \"msg_date\": \"Mon, 14 Sep 2015 10:44:40 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"\\n\\nOn 09/14/2015 10:23 AM, Shulgin, Oleksandr wrote:\\n> On Sat, Sep 12, 2015 at 11:50 AM, Tomas Vondra\\n> <tomas.vondra@2ndquadrant.com <mailto:tomas.vondra@2ndquadrant.com>> wrote:\\n...\\n> - Attempts to get plan for simple insert queries like this\\n>\\n> INSERT INTO x SELECT * FROM x;\\n>\\n> end with a segfault, because ActivePortal->queryDesc is 0x0 for this\\n> query. Needs investigation.\\n>\\n>\\n> Yes, I've hit the same problem after submitting the latest version of\\n> the patch. For now I've just added a check for queryDesc being not\\n> NULL, but I guess the top of the current_query_stack might contains\\n> something useful. Something I need to try.\\n\\nWell, the thing is we're able to do EXPLAIN on those queries, and IIRC \\nauto_explain can log them too. So perhaps look into the hooks where they \\ntake the queryDesc in those cases - it has to be available somewhere.\\n\\n> - The lockless approach seems fine to me, although I think the fear\\n> of performance issues is a bit moot (I don't think we expect large\\n> number of processes calling pg_cmdstatus at the same time). But\\n> it's not significantly more complex, so why not.\\n>\\n>\\n> I believe the main benefit of the less-locking approach is that if\\n> something goes wrong when two backends tried to communicate it doesn't\\n> prevent the rest of them from operating, because there is no shared (and\\n> thus locked) communication channel.\\n\\nSure, but I think it really deserves a bit more detailed explanation of \\nthe protocol, and discussion of the expected behavior for some basic \\nfailure types.\\n\\nFor example - what happens when a backend requests info, but dies before \\nreceiving it, and the backed is reused for another connection? Doesn't \\nthis introduce a race condition? Perhaps not, I'm just asking.\\n\\n>\\n> - The patch contains pretty much no documentation, both comments\\n> at the code level and user docs. The lack of user docs is not that\\n> a big deal at this point (although the patch seems to be mature\\n> enough, although the user-level API will likely change).\\n>\\n> The lack of code comments is more serious, as it makes the review\\n> somewhat more difficult. For example it'd be very nice to document\\n> the contract for the lock-less interface.\\n>\\n>\\n> I will add the code comments. The user docs could wait before we decide\\n> on the interface, I think.\\n\\nAgreed, although I think having rudimentary user documentation would be \\nuseful for the reviewers - a summary of the goals that are a bit \\nscattered over the e-mail thread.\\n\\n> - I agree that pg_cmdstatus() is not the best API. Having something\\n> like EXPLAIN PID would be nice, but it does not really work for\\n> all the request types (just CMD_STATUS_REQUEST_EXPLAIN). Maybe\\n> there's not a single API for all cases, i.e. we should use EXPLAIN\\n> PID for one case and invent something different for the other?\\n>\\n>\\n> I can think of something like:\\n>\\n> EXPLAIN [ ( option [, ...] ) ] PROCESS <PID>;\\n>\\n> where option is extended with:\\n>\\n> QUERY\\n> PROGRESS\\n> BACKTRACE\\n>\\n> in addition to the usual ANALYZE, VERBOSE, FORMAT, etc.\\n\\nSeems OK. I'm not quite sure what PROGRESS is - I assume it's the same \\nthing as ANALYZE? Why not to use the keyword, then?\\n\\n>\\n> - Is there a particular reason why we allocate slots for auxiliary\\n> processes and not just for backends (NumBackends)? Do we expect those\\n> auxiliary processes to ever use this API?\\n>\\n>\\n> If we extend the interface to a more general one, there still might be\\n> some space for querying status of checkpointer of bgwriter.\\n\\nI don't think we should mix this with monitoring of auxiliary processes. \\nThis interface is designed at monitoring SQL queries running in other \\nbackends, effectively \\\"remote\\\" EXPLAIN. But those auxiliary processes \\nare not processing SQL queries at all, they're not even using regular \\nexecutor ...\\n\\nOTOH the ability to request this info (e.g. auxiliary process looking at \\nplans running in backends) seems useful, so I'm ok with tuple slots for \\nauxiliary processes.\\n\\n>\\n> - CleanupCmdStatusSlot seems needlessly complicated. I don't quite see\\n> the need for the second argument, or the internal slot variable. Why\\n> not to simply use the MyCmdStatusSlot directly?\\n>\\n>\\n> Good point.\\n>\\n> - I also don't quite understand why we need to track css_pid for the\\n> slot? In what scenario will this actually matter?\\n>\\n>\\n> I think it's being only used for error reporting and could help in\\n> debugging, but for now that's it.\\n\\nI recommend getting rid of it, unless we have a clear idea of how to use \\nit. Otherwise I envision we won't really keep it updated properly \\n(because it's \\\"just for debugging\\\"), and then one day someone actually \\nstarts using it and get bitten by it.\\n\\n>\\n> - While being able to get EXPLAIN from the running process is nice,\\n> I'm especially interested in getting EXPLAIN ANALYZE to get insight\\n> into the progress of the execution. The are other ways to get the\\n> EXPLAIN, e.g. by opening a different connection and actually running\\n> it (sure, the plan might have changed since then), but currently\\n> there's no way to get insight into the progress.\\n>\\n> From the thread I get the impression that Oleksandr also finds this\\n> useful - correct? What are the plans in this direction?\\n>\\n> ISTM we need at least two things for that to work:\\n>\\n> (a) Ability to enable instrumentation on all queries (effectively\\n> what auto_explain allows), otherwise we can't get EXPLAIN ANALYZE\\n> on the queries later. But auto_explain is an extension, so that\\n> does not seem as a good match if this is supposed to be in core.\\n> In that case a separate GUC seems appropriate.\\n>\\n> (b) Being able to run the InstrEnd* methods repeatedly - the initial\\n> message in this thread mentions issues with InstrEndLoop for\\n> example. So perhaps this is non-trivial.\\n>\\n>\\n> I was able to make this work with a simple change to InstrEndLoop and\\n> the callers. Basically, adding a bool parameter in_explain and passing\\n> an appropriate value. I guess that's not the best approach, but it\\n> appears to work.\\n>\\n> Adding a GUC to enable instrumentation sounds reasonable.\\n\\nNice!\\n\\n>\\n> Do you believe it makes sense to add instrumentation support in this\\n> same patch or better focus on making the simplest thing work first?\\n\\nLet's make it a \\\"patch series\\\" with two patches.\\n\\n>\\n> - And finally, I think we should really support all existing EXPLAIN\\n> formats, not just text. We need to support the other formats (yaml,\\n> json, xml) if we want to use the EXPLAIN PID approach, and it also\\n> makes the plans easier to process by additional tools.\\n>\\n>\\n> Sure, that was in my plans (and see above for possible syntax). What\\n> would be really neat is retrieving the complete backtrace. Not sure\\n> what the good interface would look like, but using JSON format for the\\n> output sounds promising.\\n\\nI don't quite see the reason to encode everything as JSON, because that \\nmakes it a bit difficult for clients that would prefer YAML, for \\nexample. Why not to just use the requested format? For example in YAML, \\nwe can do something like this:\\n\\n QUERY PLAN\\n----------------------------------\\n - Plan[0]: +\\n Node Type: \\\"Index Only Scan\\\"+\\n Scan Direction: \\\"Forward\\\" +\\n ... +\\n +\\n - Plan[1]: +\\n Node Type: \\\"Index Only Scan\\\"+\\n Scan Direction: \\\"Forward\\\" +\\n ... +\\n +\\n - Plan[2]: +\\n Node Type: \\\"Index Only Scan\\\"+\\n Scan Direction: \\\"Forward\\\" +\\n ... +\\n\\nand similarly for other formats. We don't really use nesting.\\n\\nregards\\n\\n-- \\nTomas Vondra http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 14 Sep 2015 11:53:02 +0200\",\n \"msg_from\": \"Tomas Vondra <tomas.vondra@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and\\n signals\"\n },\n {\n \"msg_contents\": \"On Mon, Sep 14, 2015 at 11:53 AM, Tomas Vondra <tomas.vondra@2ndquadrant.com\\n> wrote:\\n\\n>\\n> On 09/14/2015 10:23 AM, Shulgin, Oleksandr wrote:\\n>\\n>> On Sat, Sep 12, 2015 at 11:50 AM, Tomas Vondra\\n>> <tomas.vondra@2ndquadrant.com <mailto:tomas.vondra@2ndquadrant.com>>\\n>> wrote:\\n>>\\n> ...\\n>\\n>> - Attempts to get plan for simple insert queries like this\\n>>\\n>> INSERT INTO x SELECT * FROM x;\\n>>\\n>> end with a segfault, because ActivePortal->queryDesc is 0x0 for\\n>> this\\n>> query. Needs investigation.\\n>>\\n>>\\n>> Yes, I've hit the same problem after submitting the latest version of\\n>> the patch. For now I've just added a check for queryDesc being not\\n>> NULL, but I guess the top of the current_query_stack might contains\\n>> something useful. Something I need to try.\\n>>\\n>\\n> Well, the thing is we're able to do EXPLAIN on those queries, and IIRC\\n> auto_explain can log them too. So perhaps look into the hooks where they\\n> take the queryDesc in those cases - it has to be available somewhere.\\n\\n\\nYes, this seems to work. I was able to successfully query \\\"create table\\nas\\\" and even \\\"explain analyze\\\" for the plans. In both cases ActivePortal\\ndoesn't have a valid queryDesc, but the executor hook captures one.\\n\\n - The lockless approach seems fine to me, although I think the fear\\n>> of performance issues is a bit moot (I don't think we expect large\\n>> number of processes calling pg_cmdstatus at the same time). But\\n>> it's not significantly more complex, so why not.\\n>>\\n>>\\n>> I believe the main benefit of the less-locking approach is that if\\n>> something goes wrong when two backends tried to communicate it doesn't\\n>> prevent the rest of them from operating, because there is no shared (and\\n>> thus locked) communication channel.\\n>>\\n>\\n> Sure, but I think it really deserves a bit more detailed explanation of\\n> the protocol, and discussion of the expected behavior for some basic\\n> failure types.\\n>\\n> For example - what happens when a backend requests info, but dies before\\n> receiving it, and the backed is reused for another connection? Doesn't this\\n> introduce a race condition? Perhaps not, I'm just asking.\\n\\n\\nNow explained better in code comments.\\n\\nThe worst thing that could happen in this case I believe is that the\\nrequesting backend will not receive any response from the second use of its\\nslot due to the slot being marked as processed by the backend that was\\nasked first:\\n\\nA:\\nslot->is_processed = false;\\nslot->is_valid = true;\\n/* signals backend B */;\\nshm_mq_read(); /* blocks */\\n\\nB: /* finds the slot and prepares the response */\\n\\nA: /* decides to bail out */\\nInvalidateCmdStatusSlot();\\nshm_mq_detach();\\n/* exits pg_cmdstatus() */\\n\\n/* pg_cmdstatus() is called again */\\n/* initializes the slot and signals some backend */\\nshm_mq_read(); /* blocks */\\n\\nB: /* completes preparing the response */\\nslot->is_processed = true;\\nshm_mq_send() => SHM_MQ_DETACHED\\nslot->is_valid = false;\\n/* gives up with this slot */\\n\\nNow the backend that has been signaled on the second call to pg_cmdstatus\\n(it can be either some other backend, or the backend B again) will not find\\nan unprocessed slot, thus it will not try to attach/detach the queue and\\nthe backend A will block forever.\\n\\nThis requires a really bad timing and the user should be able to interrupt\\nthe querying backend A still.\\n\\nIn any case, the backends that are being asked to send the info will be\\nable to notice the problem (receiver detached early) and handle it\\ngracefully.\\n\\n - The patch contains pretty much no documentation, both comments\\n>> at the code level and user docs. The lack of user docs is not that\\n>> a big deal at this point (although the patch seems to be mature\\n>> enough, although the user-level API will likely change).\\n>>\\n>> The lack of code comments is more serious, as it makes the review\\n>> somewhat more difficult. For example it'd be very nice to document\\n>> the contract for the lock-less interface.\\n>>\\n>>\\n>> I will add the code comments. The user docs could wait before we decide\\n>> on the interface, I think.\\n>>\\n>\\n> Agreed, although I think having rudimentary user documentation would be\\n> useful for the reviewers - a summary of the goals that are a bit scattered\\n> over the e-mail thread.\\n\\n\\nOK\\n\\n - I agree that pg_cmdstatus() is not the best API. Having something\\n>> like EXPLAIN PID would be nice, but it does not really work for\\n>> all the request types (just CMD_STATUS_REQUEST_EXPLAIN). Maybe\\n>> there's not a single API for all cases, i.e. we should use EXPLAIN\\n>> PID for one case and invent something different for the other?\\n>>\\n>>\\n>> I can think of something like:\\n>>\\n>> EXPLAIN [ ( option [, ...] ) ] PROCESS <PID>;\\n>>\\n>> where option is extended with:\\n>>\\n>> QUERY\\n>> PROGRESS\\n>> BACKTRACE\\n>>\\n>> in addition to the usual ANALYZE, VERBOSE, FORMAT, etc.\\n>>\\n>\\n> Seems OK. I'm not quite sure what PROGRESS is - I assume it's the same\\n> thing as ANALYZE? Why not to use the keyword, then?\\n\\n\\nThis is what CMD_INFO_PROGRESS_TAG does: return the \\\"partial completion\\\"\\ncommand tag, like \\\"INSERT 12345\\\", reflecting the number of tuples processed\\nup to this point in time.\\n\\n - Is there a particular reason why we allocate slots for auxiliary\\n>> processes and not just for backends (NumBackends)? Do we expect\\n>> those\\n>> auxiliary processes to ever use this API?\\n>>\\n>>\\n>> If we extend the interface to a more general one, there still might be\\n>> some space for querying status of checkpointer of bgwriter.\\n>>\\n>\\n> I don't think we should mix this with monitoring of auxiliary processes.\\n> This interface is designed at monitoring SQL queries running in other\\n> backends, effectively \\\"remote\\\" EXPLAIN. But those auxiliary processes are\\n> not processing SQL queries at all, they're not even using regular executor\\n> ...\\n>\\n> OTOH the ability to request this info (e.g. auxiliary process looking at\\n> plans running in backends) seems useful, so I'm ok with tuple slots for\\n> auxiliary processes.\\n\\n\\nNow that I think about it, reserving the slots for aux process doesn't let\\nus query their status, it's the other way round. If we don't reserve them,\\nthen aux process would not be able to query any other process for the\\nstatus. Likely this is not a problem at all, so we can remove these extra\\nslots.\\n\\n - CleanupCmdStatusSlot seems needlessly complicated. I don't quite see\\n>> the need for the second argument, or the internal slot variable.\\n>> Why\\n>> not to simply use the MyCmdStatusSlot directly?\\n>>\\n>>\\n>> Good point.\\n>>\\n>> - I also don't quite understand why we need to track css_pid for the\\n>> slot? In what scenario will this actually matter?\\n>>\\n>>\\n>> I think it's being only used for error reporting and could help in\\n>> debugging, but for now that's it.\\n>>\\n>\\n> I recommend getting rid of it, unless we have a clear idea of how to use\\n> it. Otherwise I envision we won't really keep it updated properly (because\\n> it's \\\"just for debugging\\\"), and then one day someone actually starts using\\n> it and get bitten by it.\\n\\n\\nThe design was copied over from procsignal.c, where the pss_pid is used to\\n\\\"claim\\\" the procsignal slot. There it's used for searching the target\\nprocess slot when backend id is not known. We don't use that in cmd status\\nslots because of the inverted slots logic, so we could really remove this\\nfield.\\n\\n - While being able to get EXPLAIN from the running process is nice,\\n>> I'm especially interested in getting EXPLAIN ANALYZE to get insight\\n>> into the progress of the execution. The are other ways to get the\\n>> EXPLAIN, e.g. by opening a different connection and actually\\n>> running\\n>> it (sure, the plan might have changed since then), but currently\\n>> there's no way to get insight into the progress.\\n>>\\n>> From the thread I get the impression that Oleksandr also finds this\\n>> useful - correct? What are the plans in this direction?\\n>>\\n>> ISTM we need at least two things for that to work:\\n>>\\n>> (a) Ability to enable instrumentation on all queries (effectively\\n>> what auto_explain allows), otherwise we can't get EXPLAIN\\n>> ANALYZE\\n>> on the queries later. But auto_explain is an extension, so that\\n>> does not seem as a good match if this is supposed to be in\\n>> core.\\n>> In that case a separate GUC seems appropriate.\\n>>\\n>> (b) Being able to run the InstrEnd* methods repeatedly - the\\n>> initial\\n>> message in this thread mentions issues with InstrEndLoop for\\n>> example. So perhaps this is non-trivial.\\n>>\\n>>\\n>> I was able to make this work with a simple change to InstrEndLoop and\\n>> the callers. Basically, adding a bool parameter in_explain and passing\\n>> an appropriate value. I guess that's not the best approach, but it\\n>> appears to work.\\n>>\\n>> Adding a GUC to enable instrumentation sounds reasonable.\\n>>\\n>\\n> Nice!\\n>\\n>\\n>> Do you believe it makes sense to add instrumentation support in this\\n>> same patch or better focus on making the simplest thing work first?\\n>>\\n>\\n> Let's make it a \\\"patch series\\\" with two patches.\\n\\n\\nOK, I'll submit them later today after addressing all the comments.\\n\\n - And finally, I think we should really support all existing EXPLAIN\\n>> formats, not just text. We need to support the other formats (yaml,\\n>> json, xml) if we want to use the EXPLAIN PID approach, and it also\\n>> makes the plans easier to process by additional tools.\\n>>\\n>>\\n>> Sure, that was in my plans (and see above for possible syntax). What\\n>> would be really neat is retrieving the complete backtrace. Not sure\\n>> what the good interface would look like, but using JSON format for the\\n>> output sounds promising.\\n>>\\n>\\n> I don't quite see the reason to encode everything as JSON, because that\\n> makes it a bit difficult for clients that would prefer YAML, for example.\\n> Why not to just use the requested format? For example in YAML, we can do\\n> something like this:\\n>\\n> QUERY PLAN\\n> ----------------------------------\\n> - Plan[0]: +\\n> Node Type: \\\"Index Only Scan\\\"+\\n> Scan Direction: \\\"Forward\\\" +\\n> ... +\\n> +\\n> - Plan[1]: +\\n> Node Type: \\\"Index Only Scan\\\"+\\n> Scan Direction: \\\"Forward\\\" +\\n> ... +\\n> +\\n> - Plan[2]: +\\n> Node Type: \\\"Index Only Scan\\\"+\\n> Scan Direction: \\\"Forward\\\" +\\n> ... +\\n>\\n> and similarly for other formats. We don't really use nesting.\\n\\n\\nYou're right, the nesting structure is too simple to require a certain\\nformat. Do you have ideas about representing stack frames in TEXT format?\\nSomething like what gdb does with #0, #1, etc. markers for frame depth?\\n\\n--\\nAlex\\n\\nOn Mon, Sep 14, 2015 at 11:53 AM, Tomas Vondra <tomas.vondra@2ndquadrant.com> wrote:\\nOn 09/14/2015 10:23 AM, Shulgin, Oleksandr wrote:\\n\\nOn Sat, Sep 12, 2015 at 11:50 AM, Tomas Vondra\\n<tomas.vondra@2ndquadrant.com <mailto:tomas.vondra@2ndquadrant.com>> wrote:\\n\\n...\\n\\n - Attempts to get plan for simple insert queries like this\\n\\n INSERT INTO x SELECT * FROM x;\\n\\n end with a segfault, because ActivePortal->queryDesc is 0x0 for this\\n query. Needs investigation.\\n\\n\\nYes, I've hit the same problem after submitting the latest version of\\nthe patch. For now I've just added a check for queryDesc being not\\nNULL, but I guess the top of the current_query_stack might contains\\nsomething useful. Something I need to try.\\n\\n\\nWell, the thing is we're able to do EXPLAIN on those queries, and IIRC auto_explain can log them too. So perhaps look into the hooks where they take the queryDesc in those cases - it has to be available somewhere.Yes, this seems to work. I was able to successfully query \\\"create table as\\\" and even \\\"explain analyze\\\" for the plans. In both cases ActivePortal doesn't have a valid queryDesc, but the executor hook captures one.\\n\\n - The lockless approach seems fine to me, although I think the fear\\n of performance issues is a bit moot (I don't think we expect large\\n number of processes calling pg_cmdstatus at the same time). But\\n it's not significantly more complex, so why not.\\n\\n\\nI believe the main benefit of the less-locking approach is that if\\nsomething goes wrong when two backends tried to communicate it doesn't\\nprevent the rest of them from operating, because there is no shared (and\\nthus locked) communication channel.\\n\\n\\nSure, but I think it really deserves a bit more detailed explanation of the protocol, and discussion of the expected behavior for some basic failure types.\\n\\nFor example - what happens when a backend requests info, but dies before receiving it, and the backed is reused for another connection? Doesn't this introduce a race condition? Perhaps not, I'm just asking.Now explained better in code comments.The worst thing that could happen in this case I believe is that the requesting backend will not receive any response from the second use of its slot due to the slot being marked as processed by the backend that was asked first:A:slot->is_processed = false;slot->is_valid = true;/* signals backend B */;shm_mq_read(); /* blocks */B: /* finds the slot and prepares the response */A: /* decides to bail out */InvalidateCmdStatusSlot();shm_mq_detach();/* exits pg_cmdstatus() *//* pg_cmdstatus() is called again *//* initializes the slot and signals some backend */shm_mq_read(); /* blocks */B: /* completes preparing the response */slot->is_processed = true;shm_mq_send() => SHM_MQ_DETACHEDslot->is_valid = false;/* gives up with this slot */Now the backend that has been signaled on the second call to pg_cmdstatus (it can be either some other backend, or the backend B again) will not find an unprocessed slot, thus it will not try to attach/detach the queue and the backend A will block forever.This requires a really bad timing and the user should be able to interrupt the querying backend A still.In any case, the backends that are being asked to send the info will be able to notice the problem (receiver detached early) and handle it gracefully.\\n - The patch contains pretty much no documentation, both comments\\n at the code level and user docs. The lack of user docs is not that\\n a big deal at this point (although the patch seems to be mature\\n enough, although the user-level API will likely change).\\n\\n The lack of code comments is more serious, as it makes the review\\n somewhat more difficult. For example it'd be very nice to document\\n the contract for the lock-less interface.\\n\\n\\nI will add the code comments. The user docs could wait before we decide\\non the interface, I think.\\n\\n\\nAgreed, although I think having rudimentary user documentation would be useful for the reviewers - a summary of the goals that are a bit scattered over the e-mail thread.OK\\n\\n - I agree that pg_cmdstatus() is not the best API. Having something\\n like EXPLAIN PID would be nice, but it does not really work for\\n all the request types (just CMD_STATUS_REQUEST_EXPLAIN). Maybe\\n there's not a single API for all cases, i.e. we should use EXPLAIN\\n PID for one case and invent something different for the other?\\n\\n\\nI can think of something like:\\n\\nEXPLAIN [ ( option [, ...] ) ] PROCESS <PID>;\\n\\nwhere option is extended with:\\n\\n QUERY\\n PROGRESS\\n BACKTRACE\\n\\nin addition to the usual ANALYZE, VERBOSE, FORMAT, etc.\\n\\n\\nSeems OK. I'm not quite sure what PROGRESS is - I assume it's the same thing as ANALYZE? Why not to use the keyword, then?This is what CMD_INFO_PROGRESS_TAG does: return the \\\"partial completion\\\" command tag, like \\\"INSERT 12345\\\", reflecting the number of tuples processed up to this point in time.\\n - Is there a particular reason why we allocate slots for auxiliary\\n processes and not just for backends (NumBackends)? Do we expect those\\n auxiliary processes to ever use this API?\\n\\n\\nIf we extend the interface to a more general one, there still might be\\nsome space for querying status of checkpointer of bgwriter.\\n\\n\\nI don't think we should mix this with monitoring of auxiliary processes. This interface is designed at monitoring SQL queries running in other backends, effectively \\\"remote\\\" EXPLAIN. But those auxiliary processes are not processing SQL queries at all, they're not even using regular executor ...\\n\\nOTOH the ability to request this info (e.g. auxiliary process looking at plans running in backends) seems useful, so I'm ok with tuple slots for auxiliary processes.Now that I think about it, reserving the slots for aux process doesn't let us query their status, it's the other way round. If we don't reserve them, then aux process would not be able to query any other process for the status. Likely this is not a problem at all, so we can remove these extra slots.\\n - CleanupCmdStatusSlot seems needlessly complicated. I don't quite see\\n the need for the second argument, or the internal slot variable. Why\\n not to simply use the MyCmdStatusSlot directly?\\n\\n\\nGood point.\\n\\n - I also don't quite understand why we need to track css_pid for the\\n slot? In what scenario will this actually matter?\\n\\n\\nI think it's being only used for error reporting and could help in\\ndebugging, but for now that's it.\\n\\n\\nI recommend getting rid of it, unless we have a clear idea of how to use it. Otherwise I envision we won't really keep it updated properly (because it's \\\"just for debugging\\\"), and then one day someone actually starts using it and get bitten by it.The design was copied over from procsignal.c, where the pss_pid is used to \\\"claim\\\" the procsignal slot. There it's used for searching the target process slot when backend id is not known. We don't use that in cmd status slots because of the inverted slots logic, so we could really remove this field.\\n - While being able to get EXPLAIN from the running process is nice,\\n I'm especially interested in getting EXPLAIN ANALYZE to get insight\\n into the progress of the execution. The are other ways to get the\\n EXPLAIN, e.g. by opening a different connection and actually running\\n it (sure, the plan might have changed since then), but currently\\n there's no way to get insight into the progress.\\n\\n From the thread I get the impression that Oleksandr also finds this\\n useful - correct? What are the plans in this direction?\\n\\n ISTM we need at least two things for that to work:\\n\\n (a) Ability to enable instrumentation on all queries (effectively\\n what auto_explain allows), otherwise we can't get EXPLAIN ANALYZE\\n on the queries later. But auto_explain is an extension, so that\\n does not seem as a good match if this is supposed to be in core.\\n In that case a separate GUC seems appropriate.\\n\\n (b) Being able to run the InstrEnd* methods repeatedly - the initial\\n message in this thread mentions issues with InstrEndLoop for\\n example. So perhaps this is non-trivial.\\n\\n\\nI was able to make this work with a simple change to InstrEndLoop and\\nthe callers. Basically, adding a bool parameter in_explain and passing\\nan appropriate value. I guess that's not the best approach, but it\\nappears to work.\\n\\nAdding a GUC to enable instrumentation sounds reasonable.\\n\\n\\nNice!\\n\\n\\n\\nDo you believe it makes sense to add instrumentation support in this\\nsame patch or better focus on making the simplest thing work first?\\n\\n\\nLet's make it a \\\"patch series\\\" with two patches.OK, I'll submit them later today after addressing all the comments.\\n - And finally, I think we should really support all existing EXPLAIN\\n formats, not just text. We need to support the other formats (yaml,\\n json, xml) if we want to use the EXPLAIN PID approach, and it also\\n makes the plans easier to process by additional tools.\\n\\n\\nSure, that was in my plans (and see above for possible syntax). What\\nwould be really neat is retrieving the complete backtrace. Not sure\\nwhat the good interface would look like, but using JSON format for the\\noutput sounds promising.\\n\\n\\nI don't quite see the reason to encode everything as JSON, because that makes it a bit difficult for clients that would prefer YAML, for example. Why not to just use the requested format? For example in YAML, we can do something like this:\\n\\n QUERY PLAN\\n----------------------------------\\n - Plan[0]: +\\n Node Type: \\\"Index Only Scan\\\"+\\n Scan Direction: \\\"Forward\\\" +\\n ... +\\n +\\n - Plan[1]: +\\n Node Type: \\\"Index Only Scan\\\"+\\n Scan Direction: \\\"Forward\\\" +\\n ... +\\n +\\n - Plan[2]: +\\n Node Type: \\\"Index Only Scan\\\"+\\n Scan Direction: \\\"Forward\\\" +\\n ... +\\n\\nand similarly for other formats. We don't really use nesting.You're right, the nesting structure is too simple to require a certain format. Do you have ideas about representing stack frames in TEXT format? Something like what gdb does with #0, #1, etc. markers for frame depth?--Alex\",\n \"msg_date\": \"Mon, 14 Sep 2015 13:15:38 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"\\n\\nOn 09/14/2015 01:15 PM, Shulgin, Oleksandr wrote:\\n> On Mon, Sep 14, 2015 at 11:53 AM, Tomas Vondra\\n> <tomas.vondra@2ndquadrant.com <mailto:tomas.vondra@2ndquadrant.com>> wrote:\\n>\\n>\\n> On 09/14/2015 10:23 AM, Shulgin, Oleksandr wrote:\\n>\\n> On Sat, Sep 12, 2015 at 11:50 AM, Tomas Vondra\\n> <tomas.vondra@2ndquadrant.com\\n> <mailto:tomas.vondra@2ndquadrant.com>\\n> <mailto:tomas.vondra@2ndquadrant.com\\n> <mailto:tomas.vondra@2ndquadrant.com>>> wrote:\\n>\\n> ...\\n>\\n> - Attempts to get plan for simple insert queries like this\\n>\\n> INSERT INTO x SELECT * FROM x;\\n>\\n> end with a segfault, because ActivePortal->queryDesc is\\n> 0x0 for this\\n> query. Needs investigation.\\n>\\n>\\n> Yes, I've hit the same problem after submitting the latest\\n> version of\\n> the patch. For now I've just added a check for queryDesc being not\\n> NULL, but I guess the top of the current_query_stack might contains\\n> something useful. Something I need to try.\\n>\\n>\\n> Well, the thing is we're able to do EXPLAIN on those queries, and\\n> IIRC auto_explain can log them too. So perhaps look into the hooks\\n> where they take the queryDesc in those cases - it has to be\\n> available somewhere.\\n>\\n>\\n> Yes, this seems to work. I was able to successfully query \\\"create table\\n> as\\\" and even \\\"explain analyze\\\" for the plans. In both cases\\n> ActivePortal doesn't have a valid queryDesc, but the executor hook\\n> captures one.\\n>\\n> - The lockless approach seems fine to me, although I think\\n> the fear\\n> of performance issues is a bit moot (I don't think we\\n> expect large\\n> number of processes calling pg_cmdstatus at the same\\n> time). But\\n> it's not significantly more complex, so why not.\\n>\\n>\\n> I believe the main benefit of the less-locking approach is that if\\n> something goes wrong when two backends tried to communicate it\\n> doesn't\\n> prevent the rest of them from operating, because there is no\\n> shared (and\\n> thus locked) communication channel.\\n>\\n>\\n> Sure, but I think it really deserves a bit more detailed explanation\\n> of the protocol, and discussion of the expected behavior for some\\n> basic failure types.\\n>\\n> For example - what happens when a backend requests info, but dies\\n> before receiving it, and the backed is reused for another\\n> connection? Doesn't this introduce a race condition? Perhaps not,\\n> I'm just asking.\\n>\\n>\\n> Now explained better in code comments.\\n>\\n> The worst thing that could happen in this case I believe is that the\\n> requesting backend will not receive any response from the second use of\\n> its slot due to the slot being marked as processed by the backend that\\n> was asked first:\\n>\\n> A:\\n> slot->is_processed = false;\\n> slot->is_valid = true;\\n> /* signals backend B */;\\n> shm_mq_read(); /* blocks */\\n>\\n> B: /* finds the slot and prepares the response */\\n>\\n> A: /* decides to bail out */\\n> InvalidateCmdStatusSlot();\\n> shm_mq_detach();\\n> /* exits pg_cmdstatus() */\\n>\\n> /* pg_cmdstatus() is called again */\\n> /* initializes the slot and signals some backend */\\n> shm_mq_read(); /* blocks */\\n>\\n> B: /* completes preparing the response */\\n> slot->is_processed = true;\\n> shm_mq_send() => SHM_MQ_DETACHED\\n> slot->is_valid = false;\\n> /* gives up with this slot */\\n>\\n> Now the backend that has been signaled on the second call to\\n> pg_cmdstatus (it can be either some other backend, or the backend B\\n> again) will not find an unprocessed slot, thus it will not try to\\n> attach/detach the queue and the backend A will block forever.\\n>\\n> This requires a really bad timing and the user should be able to\\n> interrupt the querying backend A still.\\n\\nI think we can't rely on the low probability that this won't happen, and \\nwe should not rely on people interrupting the backend. Being able to \\ndetect the situation and fail gracefully should be possible.\\n\\nIt may be possible to introduce some lock-less protocol preventing such \\nsituations, but it's not there at the moment. If you believe it's \\npossible, you need to explain and \\\"prove\\\" that it's actually safe.\\n\\nOtherwise we may need to introduce some basic locking - for example we \\nmay introduce a LWLock for each slot, and lock it with dontWait=true \\n(and skip it if we couldn't lock it). This should prevent most scenarios \\nwhere one corrupted slot blocks many processes.\\n\\n>\\n> In any case, the backends that are being asked to send the info will be\\n> able to notice the problem (receiver detached early) and handle it\\n> gracefully.\\n\\nUmmm, how? Maybe I missed something?\\n\\n\\n> I don't think we should mix this with monitoring of auxiliary\\n> processes. This interface is designed at monitoring SQL queries\\n> running in other backends, effectively \\\"remote\\\" EXPLAIN. But those\\n> auxiliary processes are not processing SQL queries at all, they're\\n> not even using regular executor ...\\n>\\n> OTOH the ability to request this info (e.g. auxiliary process\\n> looking at plans running in backends) seems useful, so I'm ok with\\n> tuple slots for auxiliary processes.\\n>\\n>\\n> Now that I think about it, reserving the slots for aux process doesn't\\n> let us query their status, it's the other way round. If we don't\\n> reserve them, then aux process would not be able to query any other\\n> process for the status. Likely this is not a problem at all, so we can\\n> remove these extra slots.\\n\\nI don't know. I can imagine using this from background workers, but I \\nthink those are counted as regular backends (not sure though).\\n\\n>\\n> - I also don't quite understand why we need to track\\n> css_pid for the\\n> slot? In what scenario will this actually matter?\\n>\\n>\\n> I think it's being only used for error reporting and could help in\\n> debugging, but for now that's it.\\n>\\n>\\n> I recommend getting rid of it, unless we have a clear idea of how to\\n> use it. Otherwise I envision we won't really keep it updated\\n> properly (because it's \\\"just for debugging\\\"), and then one day\\n> someone actually starts using it and get bitten by it.\\n>\\n>\\n> The design was copied over from procsignal.c, where the pss_pid is used\\n> to \\\"claim\\\" the procsignal slot. There it's used for searching the\\n> target process slot when backend id is not known. We don't use that in\\n> cmd status slots because of the inverted slots logic, so we could really\\n> remove this field.\\n\\nOK.\\n\\n> I don't quite see the reason to encode everything as JSON, because\\n> that makes it a bit difficult for clients that would prefer YAML,\\n> for example. Why not to just use the requested format? For example\\n> in YAML, we can do something like this:\\n>\\n> QUERY PLAN\\n> ----------------------------------\\n> - Plan[0]: +\\n> Node Type: \\\"Index Only Scan\\\"+\\n> Scan Direction: \\\"Forward\\\" +\\n> ... +\\n> +\\n> - Plan[1]: +\\n> Node Type: \\\"Index Only Scan\\\"+\\n> Scan Direction: \\\"Forward\\\" +\\n> ... +\\n> +\\n> - Plan[2]: +\\n> Node Type: \\\"Index Only Scan\\\"+\\n> Scan Direction: \\\"Forward\\\" +\\n> ... +\\n>\\n> and similarly for other formats. We don't really use nesting.\\n>\\n>\\n> You're right, the nesting structure is too simple to require a certain\\n> format. Do you have ideas about representing stack frames in TEXT\\n> format? Something like what gdb does with #0, #1, etc. markers for\\n> frame depth?\\n\\nYes. The simpler the format, the better.\\n\\nregards\\n\\n-- \\nTomas Vondra http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 14 Sep 2015 14:11:10 +0200\",\n \"msg_from\": \"Tomas Vondra <tomas.vondra@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and\\n signals\"\n },\n {\n \"msg_contents\": \"2015-09-14 14:11 GMT+02:00 Tomas Vondra <tomas.vondra@2ndquadrant.com>:\\n\\n>\\n>\\n> On 09/14/2015 01:15 PM, Shulgin, Oleksandr wrote:\\n>\\n>> On Mon, Sep 14, 2015 at 11:53 AM, Tomas Vondra\\n>> <tomas.vondra@2ndquadrant.com <mailto:tomas.vondra@2ndquadrant.com>>\\n>> wrote:\\n>>\\n>>\\n>> On 09/14/2015 10:23 AM, Shulgin, Oleksandr wrote:\\n>>\\n>> On Sat, Sep 12, 2015 at 11:50 AM, Tomas Vondra\\n>> <tomas.vondra@2ndquadrant.com\\n>> <mailto:tomas.vondra@2ndquadrant.com>\\n>> <mailto:tomas.vondra@2ndquadrant.com\\n>>\\n>> <mailto:tomas.vondra@2ndquadrant.com>>> wrote:\\n>>\\n>> ...\\n>>\\n>> - Attempts to get plan for simple insert queries like this\\n>>\\n>> INSERT INTO x SELECT * FROM x;\\n>>\\n>> end with a segfault, because ActivePortal->queryDesc is\\n>> 0x0 for this\\n>> query. Needs investigation.\\n>>\\n>>\\n>> Yes, I've hit the same problem after submitting the latest\\n>> version of\\n>> the patch. For now I've just added a check for queryDesc being\\n>> not\\n>> NULL, but I guess the top of the current_query_stack might\\n>> contains\\n>> something useful. Something I need to try.\\n>>\\n>>\\n>> Well, the thing is we're able to do EXPLAIN on those queries, and\\n>> IIRC auto_explain can log them too. So perhaps look into the hooks\\n>> where they take the queryDesc in those cases - it has to be\\n>> available somewhere.\\n>>\\n>>\\n>> Yes, this seems to work. I was able to successfully query \\\"create table\\n>> as\\\" and even \\\"explain analyze\\\" for the plans. In both cases\\n>> ActivePortal doesn't have a valid queryDesc, but the executor hook\\n>> captures one.\\n>>\\n>> - The lockless approach seems fine to me, although I think\\n>> the fear\\n>> of performance issues is a bit moot (I don't think we\\n>> expect large\\n>> number of processes calling pg_cmdstatus at the same\\n>> time). But\\n>> it's not significantly more complex, so why not.\\n>>\\n>>\\n>> I believe the main benefit of the less-locking approach is that if\\n>> something goes wrong when two backends tried to communicate it\\n>> doesn't\\n>> prevent the rest of them from operating, because there is no\\n>> shared (and\\n>> thus locked) communication channel.\\n>>\\n>>\\n>> Sure, but I think it really deserves a bit more detailed explanation\\n>> of the protocol, and discussion of the expected behavior for some\\n>> basic failure types.\\n>>\\n>> For example - what happens when a backend requests info, but dies\\n>> before receiving it, and the backed is reused for another\\n>> connection? Doesn't this introduce a race condition? Perhaps not,\\n>> I'm just asking.\\n>>\\n>>\\n>> Now explained better in code comments.\\n>>\\n>> The worst thing that could happen in this case I believe is that the\\n>> requesting backend will not receive any response from the second use of\\n>> its slot due to the slot being marked as processed by the backend that\\n>> was asked first:\\n>>\\n>> A:\\n>> slot->is_processed = false;\\n>> slot->is_valid = true;\\n>> /* signals backend B */;\\n>> shm_mq_read(); /* blocks */\\n>>\\n>> B: /* finds the slot and prepares the response */\\n>>\\n>> A: /* decides to bail out */\\n>> InvalidateCmdStatusSlot();\\n>> shm_mq_detach();\\n>> /* exits pg_cmdstatus() */\\n>>\\n>> /* pg_cmdstatus() is called again */\\n>> /* initializes the slot and signals some backend */\\n>> shm_mq_read(); /* blocks */\\n>>\\n>> B: /* completes preparing the response */\\n>> slot->is_processed = true;\\n>> shm_mq_send() => SHM_MQ_DETACHED\\n>> slot->is_valid = false;\\n>> /* gives up with this slot */\\n>>\\n>\\nhmm .. yes - there have to be check if slot is related still to queue\\nbefore to change is_valid attribute.\\n\\nRegards\\n\\nPavel\\n\\n2015-09-14 14:11 GMT+02:00 Tomas Vondra <tomas.vondra@2ndquadrant.com>:\\n\\nOn 09/14/2015 01:15 PM, Shulgin, Oleksandr wrote:\\n\\nOn Mon, Sep 14, 2015 at 11:53 AM, Tomas Vondra\\n<tomas.vondra@2ndquadrant.com <mailto:tomas.vondra@2ndquadrant.com>> wrote:\\n\\n\\n On 09/14/2015 10:23 AM, Shulgin, Oleksandr wrote:\\n\\n On Sat, Sep 12, 2015 at 11:50 AM, Tomas Vondra\\n <tomas.vondra@2ndquadrant.com\\n <mailto:tomas.vondra@2ndquadrant.com>\\n <mailto:tomas.vondra@2ndquadrant.com\\n <mailto:tomas.vondra@2ndquadrant.com>>> wrote:\\n\\n ...\\n\\n - Attempts to get plan for simple insert queries like this\\n\\n INSERT INTO x SELECT * FROM x;\\n\\n end with a segfault, because ActivePortal->queryDesc is\\n 0x0 for this\\n query. Needs investigation.\\n\\n\\n Yes, I've hit the same problem after submitting the latest\\n version of\\n the patch. For now I've just added a check for queryDesc being not\\n NULL, but I guess the top of the current_query_stack might contains\\n something useful. Something I need to try.\\n\\n\\n Well, the thing is we're able to do EXPLAIN on those queries, and\\n IIRC auto_explain can log them too. So perhaps look into the hooks\\n where they take the queryDesc in those cases - it has to be\\n available somewhere.\\n\\n\\nYes, this seems to work. I was able to successfully query \\\"create table\\nas\\\" and even \\\"explain analyze\\\" for the plans. In both cases\\nActivePortal doesn't have a valid queryDesc, but the executor hook\\ncaptures one.\\n\\n - The lockless approach seems fine to me, although I think\\n the fear\\n of performance issues is a bit moot (I don't think we\\n expect large\\n number of processes calling pg_cmdstatus at the same\\n time). But\\n it's not significantly more complex, so why not.\\n\\n\\n I believe the main benefit of the less-locking approach is that if\\n something goes wrong when two backends tried to communicate it\\n doesn't\\n prevent the rest of them from operating, because there is no\\n shared (and\\n thus locked) communication channel.\\n\\n\\n Sure, but I think it really deserves a bit more detailed explanation\\n of the protocol, and discussion of the expected behavior for some\\n basic failure types.\\n\\n For example - what happens when a backend requests info, but dies\\n before receiving it, and the backed is reused for another\\n connection? Doesn't this introduce a race condition? Perhaps not,\\n I'm just asking.\\n\\n\\nNow explained better in code comments.\\n\\nThe worst thing that could happen in this case I believe is that the\\nrequesting backend will not receive any response from the second use of\\nits slot due to the slot being marked as processed by the backend that\\nwas asked first:\\n\\nA:\\nslot->is_processed = false;\\nslot->is_valid = true;\\n/* signals backend B */;\\nshm_mq_read(); /* blocks */\\n\\nB: /* finds the slot and prepares the response */\\n\\nA: /* decides to bail out */\\nInvalidateCmdStatusSlot();\\nshm_mq_detach();\\n/* exits pg_cmdstatus() */\\n\\n/* pg_cmdstatus() is called again */\\n/* initializes the slot and signals some backend */\\nshm_mq_read(); /* blocks */\\n\\nB: /* completes preparing the response */\\nslot->is_processed = true;\\nshm_mq_send() => SHM_MQ_DETACHED\\nslot->is_valid = false;\\n/* gives up with this slot */hmm .. yes - there have to be check if slot is related still to queue before to change is_valid attribute.RegardsPavel\",\n \"msg_date\": \"Mon, 14 Sep 2015 14:39:35 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Mon, Sep 14, 2015 at 2:11 PM, Tomas Vondra <tomas.vondra@2ndquadrant.com>\\nwrote:\\n\\n>\\n>> Now the backend that has been signaled on the second call to\\n>> pg_cmdstatus (it can be either some other backend, or the backend B\\n>> again) will not find an unprocessed slot, thus it will not try to\\n>> attach/detach the queue and the backend A will block forever.\\n>>\\n>> This requires a really bad timing and the user should be able to\\n>> interrupt the querying backend A still.\\n>>\\n>\\n> I think we can't rely on the low probability that this won't happen, and\\n> we should not rely on people interrupting the backend. Being able to detect\\n> the situation and fail gracefully should be possible.\\n>\\n> It may be possible to introduce some lock-less protocol preventing such\\n> situations, but it's not there at the moment. If you believe it's possible,\\n> you need to explain and \\\"prove\\\" that it's actually safe.\\n>\\n> Otherwise we may need to introduce some basic locking - for example we may\\n> introduce a LWLock for each slot, and lock it with dontWait=true (and skip\\n> it if we couldn't lock it). This should prevent most scenarios where one\\n> corrupted slot blocks many processes.\\n\\n\\nOK, I will revisit this part then.\\n\\nIn any case, the backends that are being asked to send the info will be\\n>> able to notice the problem (receiver detached early) and handle it\\n>> gracefully.\\n>>\\n>\\n> Ummm, how? Maybe I missed something?\\n\\n\\nWell, I didn't attach the updated patch (doing that now). The basic idea\\nis that when the backend that has requested information bails out\\nprematurely it still detaches from the shared memory queue. This makes it\\npossible for the backend being asked to detect the situation either before\\nattaching to the queue or when trying to send the data, so it won't be\\nblocked forever if the other backend failed to wait.\\n\\n I don't think we should mix this with monitoring of auxiliary\\n>> processes. This interface is designed at monitoring SQL queries\\n>> running in other backends, effectively \\\"remote\\\" EXPLAIN. But those\\n>> auxiliary processes are not processing SQL queries at all, they're\\n>> not even using regular executor ...\\n>>\\n>> OTOH the ability to request this info (e.g. auxiliary process\\n>> looking at plans running in backends) seems useful, so I'm ok with\\n>> tuple slots for auxiliary processes.\\n>>\\n>>\\n>> Now that I think about it, reserving the slots for aux process doesn't\\n>> let us query their status, it's the other way round. If we don't\\n>> reserve them, then aux process would not be able to query any other\\n>> process for the status. Likely this is not a problem at all, so we can\\n>> remove these extra slots.\\n>>\\n>\\n> I don't know. I can imagine using this from background workers, but I\\n> think those are counted as regular backends (not sure though).\\n\\n\\nMaxBackends includes the background workers, yes.\\n\\n--\\nAlex\\n\\nOn Mon, Sep 14, 2015 at 2:11 PM, Tomas Vondra <tomas.vondra@2ndquadrant.com> wrote:\\nNow the backend that has been signaled on the second call to\\npg_cmdstatus (it can be either some other backend, or the backend B\\nagain) will not find an unprocessed slot, thus it will not try to\\nattach/detach the queue and the backend A will block forever.\\n\\nThis requires a really bad timing and the user should be able to\\ninterrupt the querying backend A still.\\n\\n\\nI think we can't rely on the low probability that this won't happen, and we should not rely on people interrupting the backend. Being able to detect the situation and fail gracefully should be possible.\\n\\nIt may be possible to introduce some lock-less protocol preventing such situations, but it's not there at the moment. If you believe it's possible, you need to explain and \\\"prove\\\" that it's actually safe.\\n\\nOtherwise we may need to introduce some basic locking - for example we may introduce a LWLock for each slot, and lock it with dontWait=true (and skip it if we couldn't lock it). This should prevent most scenarios where one corrupted slot blocks many processes.OK, I will revisit this part then.In any case, the backends that are being asked to send the info will be\\nable to notice the problem (receiver detached early) and handle it\\ngracefully.\\n\\n\\nUmmm, how? Maybe I missed something?Well, I didn't attach the updated patch (doing that now). The basic idea is that when the backend that has requested information bails out prematurely it still detaches from the shared memory queue. This makes it possible for the backend being asked to detect the situation either before attaching to the queue or when trying to send the data, so it won't be blocked forever if the other backend failed to wait.\\n\\n I don't think we should mix this with monitoring of auxiliary\\n processes. This interface is designed at monitoring SQL queries\\n running in other backends, effectively \\\"remote\\\" EXPLAIN. But those\\n auxiliary processes are not processing SQL queries at all, they're\\n not even using regular executor ...\\n\\n OTOH the ability to request this info (e.g. auxiliary process\\n looking at plans running in backends) seems useful, so I'm ok with\\n tuple slots for auxiliary processes.\\n\\n\\nNow that I think about it, reserving the slots for aux process doesn't\\nlet us query their status, it's the other way round. If we don't\\nreserve them, then aux process would not be able to query any other\\nprocess for the status. Likely this is not a problem at all, so we can\\nremove these extra slots.\\n\\n\\nI don't know. I can imagine using this from background workers, but I think those are counted as regular backends (not sure though).MaxBackends includes the background workers, yes.--Alex\",\n \"msg_date\": \"Mon, 14 Sep 2015 15:09:07 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \">\\n> Well, I didn't attach the updated patch (doing that now).\\n>\\n\\nThis time for real. Sorry, it's Monday :-p\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 14 Sep 2015 15:34:10 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Mon, Sep 14, 2015 at 3:09 PM, Shulgin, Oleksandr <\\noleksandr.shulgin@zalando.de> wrote:\\n\\n> On Mon, Sep 14, 2015 at 2:11 PM, Tomas Vondra <\\n> tomas.vondra@2ndquadrant.com> wrote:\\n>\\n>>\\n>>> Now the backend that has been signaled on the second call to\\n>>> pg_cmdstatus (it can be either some other backend, or the backend B\\n>>> again) will not find an unprocessed slot, thus it will not try to\\n>>> attach/detach the queue and the backend A will block forever.\\n>>>\\n>>> This requires a really bad timing and the user should be able to\\n>>> interrupt the querying backend A still.\\n>>>\\n>>\\n>> I think we can't rely on the low probability that this won't happen, and\\n>> we should not rely on people interrupting the backend. Being able to detect\\n>> the situation and fail gracefully should be possible.\\n>>\\n>> It may be possible to introduce some lock-less protocol preventing such\\n>> situations, but it's not there at the moment. If you believe it's possible,\\n>> you need to explain and \\\"prove\\\" that it's actually safe.\\n>>\\n>> Otherwise we may need to introduce some basic locking - for example we\\n>> may introduce a LWLock for each slot, and lock it with dontWait=true (and\\n>> skip it if we couldn't lock it). This should prevent most scenarios where\\n>> one corrupted slot blocks many processes.\\n>\\n>\\n> OK, I will revisit this part then.\\n>\\n\\nI have a radical proposal to remove the need for locking: make the\\nCmdStatusSlot struct consist of a mere dsm_handle and move all the required\\nmetadata like sender_pid, request_type, etc. into the shared memory segment\\nitself.\\n\\nIf we allow the only the requesting process to update the slot (that is the\\nhandle value itself) this removes the need for locking between sender and\\nreceiver.\\n\\nThe sender will walk through the slots looking for a non-zero dsm handle\\n(according to dsm_create() implementation 0 is considered an invalid\\nhandle), and if it finds a valid one, it will attach and look inside, to\\ncheck if it's destined for this process ID. At first that might sound\\nstrange, but I would expect 99% of the time that the only valid slot would\\nbe for the process that has been just signaled.\\n\\nThe sender process will then calculate the response message, update the\\nresult_code in the shared memory segment and finally send the message\\nthrough the queue. If the receiver has since detached we get a detached\\nresult code and bail out.\\n\\nClearing the slot after receiving the message should be the requesting\\nprocess' responsibility. This way the receiver only writes to the slot and\\nthe sender only reads from it.\\n\\nBy the way, is it safe to assume atomic read/writes of dsm_handle\\n(uint32)? I would be surprised if not.\\n\\n--\\nAlex\\n\\nOn Mon, Sep 14, 2015 at 3:09 PM, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote:On Mon, Sep 14, 2015 at 2:11 PM, Tomas Vondra <tomas.vondra@2ndquadrant.com> wrote:\\nNow the backend that has been signaled on the second call to\\npg_cmdstatus (it can be either some other backend, or the backend B\\nagain) will not find an unprocessed slot, thus it will not try to\\nattach/detach the queue and the backend A will block forever.\\n\\nThis requires a really bad timing and the user should be able to\\ninterrupt the querying backend A still.\\n\\n\\nI think we can't rely on the low probability that this won't happen, and we should not rely on people interrupting the backend. Being able to detect the situation and fail gracefully should be possible.\\n\\nIt may be possible to introduce some lock-less protocol preventing such situations, but it's not there at the moment. If you believe it's possible, you need to explain and \\\"prove\\\" that it's actually safe.\\n\\nOtherwise we may need to introduce some basic locking - for example we may introduce a LWLock for each slot, and lock it with dontWait=true (and skip it if we couldn't lock it). This should prevent most scenarios where one corrupted slot blocks many processes.OK, I will revisit this part then.I have a radical proposal to remove the need for locking: make the CmdStatusSlot struct consist of a mere dsm_handle and move all the required metadata like sender_pid, request_type, etc. into the shared memory segment itself.If we allow the only the requesting process to update the slot (that is the handle value itself) this removes the need for locking between sender and receiver.The sender will walk through the slots looking for a non-zero dsm handle (according to dsm_create() implementation 0 is considered an invalid handle), and if it finds a valid one, it will attach and look inside, to check if it's destined for this process ID. At first that might sound strange, but I would expect 99% of the time that the only valid slot would be for the process that has been just signaled.The sender process will then calculate the response message, update the result_code in the shared memory segment and finally send the message through the queue. If the receiver has since detached we get a detached result code and bail out.Clearing the slot after receiving the message should be the requesting process' responsibility. This way the receiver only writes to the slot and the sender only reads from it.By the way, is it safe to assume atomic read/writes of dsm_handle (uint32)? I would be surprised if not.--Alex\",\n \"msg_date\": \"Mon, 14 Sep 2015 18:46:51 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-14 18:46 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Mon, Sep 14, 2015 at 3:09 PM, Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de> wrote:\\n>\\n>> On Mon, Sep 14, 2015 at 2:11 PM, Tomas Vondra <\\n>> tomas.vondra@2ndquadrant.com> wrote:\\n>>\\n>>>\\n>>>> Now the backend that has been signaled on the second call to\\n>>>> pg_cmdstatus (it can be either some other backend, or the backend B\\n>>>> again) will not find an unprocessed slot, thus it will not try to\\n>>>> attach/detach the queue and the backend A will block forever.\\n>>>>\\n>>>> This requires a really bad timing and the user should be able to\\n>>>> interrupt the querying backend A still.\\n>>>>\\n>>>\\n>>> I think we can't rely on the low probability that this won't happen, and\\n>>> we should not rely on people interrupting the backend. Being able to detect\\n>>> the situation and fail gracefully should be possible.\\n>>>\\n>>> It may be possible to introduce some lock-less protocol preventing such\\n>>> situations, but it's not there at the moment. If you believe it's possible,\\n>>> you need to explain and \\\"prove\\\" that it's actually safe.\\n>>>\\n>>> Otherwise we may need to introduce some basic locking - for example we\\n>>> may introduce a LWLock for each slot, and lock it with dontWait=true (and\\n>>> skip it if we couldn't lock it). This should prevent most scenarios where\\n>>> one corrupted slot blocks many processes.\\n>>\\n>>\\n>> OK, I will revisit this part then.\\n>>\\n>\\n> I have a radical proposal to remove the need for locking: make the\\n> CmdStatusSlot struct consist of a mere dsm_handle and move all the required\\n> metadata like sender_pid, request_type, etc. into the shared memory segment\\n> itself.\\n>\\n> If we allow the only the requesting process to update the slot (that is\\n> the handle value itself) this removes the need for locking between sender\\n> and receiver.\\n>\\n> The sender will walk through the slots looking for a non-zero dsm handle\\n> (according to dsm_create() implementation 0 is considered an invalid\\n> handle), and if it finds a valid one, it will attach and look inside, to\\n> check if it's destined for this process ID. At first that might sound\\n> strange, but I would expect 99% of the time that the only valid slot would\\n> be for the process that has been just signaled.\\n>\\n> The sender process will then calculate the response message, update the\\n> result_code in the shared memory segment and finally send the message\\n> through the queue. If the receiver has since detached we get a detached\\n> result code and bail out.\\n>\\n> Clearing the slot after receiving the message should be the requesting\\n> process' responsibility. This way the receiver only writes to the slot and\\n> the sender only reads from it.\\n>\\n> By the way, is it safe to assume atomic read/writes of dsm_handle\\n> (uint32)? I would be surprised if not.\\n>\\n\\nI don't see any reason why it should not to work - only few processes will\\nwait for data - so lost attach/detach shm operations will not be too much.\\n\\nPavel\\n\\n\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n2015-09-14 18:46 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Mon, Sep 14, 2015 at 3:09 PM, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote:On Mon, Sep 14, 2015 at 2:11 PM, Tomas Vondra <tomas.vondra@2ndquadrant.com> wrote:\\nNow the backend that has been signaled on the second call to\\npg_cmdstatus (it can be either some other backend, or the backend B\\nagain) will not find an unprocessed slot, thus it will not try to\\nattach/detach the queue and the backend A will block forever.\\n\\nThis requires a really bad timing and the user should be able to\\ninterrupt the querying backend A still.\\n\\n\\nI think we can't rely on the low probability that this won't happen, and we should not rely on people interrupting the backend. Being able to detect the situation and fail gracefully should be possible.\\n\\nIt may be possible to introduce some lock-less protocol preventing such situations, but it's not there at the moment. If you believe it's possible, you need to explain and \\\"prove\\\" that it's actually safe.\\n\\nOtherwise we may need to introduce some basic locking - for example we may introduce a LWLock for each slot, and lock it with dontWait=true (and skip it if we couldn't lock it). This should prevent most scenarios where one corrupted slot blocks many processes.OK, I will revisit this part then.I have a radical proposal to remove the need for locking: make the CmdStatusSlot struct consist of a mere dsm_handle and move all the required metadata like sender_pid, request_type, etc. into the shared memory segment itself.If we allow the only the requesting process to update the slot (that is the handle value itself) this removes the need for locking between sender and receiver.The sender will walk through the slots looking for a non-zero dsm handle (according to dsm_create() implementation 0 is considered an invalid handle), and if it finds a valid one, it will attach and look inside, to check if it's destined for this process ID. At first that might sound strange, but I would expect 99% of the time that the only valid slot would be for the process that has been just signaled.The sender process will then calculate the response message, update the result_code in the shared memory segment and finally send the message through the queue. If the receiver has since detached we get a detached result code and bail out.Clearing the slot after receiving the message should be the requesting process' responsibility. This way the receiver only writes to the slot and the sender only reads from it.By the way, is it safe to assume atomic read/writes of dsm_handle (uint32)? I would be surprised if not.I don't see any reason why it should not to work - only few processes will wait for data - so lost attach/detach shm operations will not be too much. Pavel --Alex\",\n \"msg_date\": \"Mon, 14 Sep 2015 19:27:15 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Mon, Sep 14, 2015 at 7:27 PM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n\\n>\\n> 2015-09-14 18:46 GMT+02:00 Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de>:\\n>\\n>>\\n>> I have a radical proposal to remove the need for locking: make the\\n>> CmdStatusSlot struct consist of a mere dsm_handle and move all the required\\n>> metadata like sender_pid, request_type, etc. into the shared memory segment\\n>> itself.\\n>>\\n>> If we allow the only the requesting process to update the slot (that is\\n>> the handle value itself) this removes the need for locking between sender\\n>> and receiver.\\n>>\\n>> The sender will walk through the slots looking for a non-zero dsm handle\\n>> (according to dsm_create() implementation 0 is considered an invalid\\n>> handle), and if it finds a valid one, it will attach and look inside, to\\n>> check if it's destined for this process ID. At first that might sound\\n>> strange, but I would expect 99% of the time that the only valid slot would\\n>> be for the process that has been just signaled.\\n>>\\n>> The sender process will then calculate the response message, update the\\n>> result_code in the shared memory segment and finally send the message\\n>> through the queue. If the receiver has since detached we get a detached\\n>> result code and bail out.\\n>>\\n>> Clearing the slot after receiving the message should be the requesting\\n>> process' responsibility. This way the receiver only writes to the slot and\\n>> the sender only reads from it.\\n>>\\n>> By the way, is it safe to assume atomic read/writes of dsm_handle\\n>> (uint32)? I would be surprised if not.\\n>>\\n>\\n> I don't see any reason why it should not to work - only few processes will\\n> wait for data - so lost attach/detach shm operations will not be too much.\\n>\\n\\nPlease see attached for implementation of this approach. The most\\nsurprising thing is that it actually works :)\\n\\nOne problem still remains with the process requesting information when the\\ntarget process exits before it can have a chance to handle the signal. The\\nrequesting process then waits forever, because nobody attaches/detaches the\\nqueue. We've discussed this before and looks like we need to introduce a\\ntimeout parameter to pg_cmdstatus()...\\n\\n--\\nAlex\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Tue, 15 Sep 2015 11:00:58 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 15, 2015 at 11:00 AM, Shulgin, Oleksandr <\\noleksandr.shulgin@zalando.de> wrote:\\n\\n> On Mon, Sep 14, 2015 at 7:27 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n>\\n>>\\n>> 2015-09-14 18:46 GMT+02:00 Shulgin, Oleksandr <\\n>> oleksandr.shulgin@zalando.de>:\\n>>\\n>>>\\n>>> ... This way the receiver only writes to the slot and the sender only\\n>>> reads from it.\\n>>>\\n>>> By the way, is it safe to assume atomic read/writes of dsm_handle\\n>>> (uint32)? I would be surprised if not.\\n>>>\\n>>\\n>> I don't see any reason why it should not to work - only few processes\\n>> will wait for data - so lost attach/detach shm operations will not be too\\n>> much.\\n>>\\n>\\n> Please see attached for implementation of this approach. The most\\n> surprising thing is that it actually works :)\\n>\\n> One problem still remains with the process requesting information when the\\n> target process exits before it can have a chance to handle the signal. The\\n> requesting process then waits forever, because nobody attaches/detaches the\\n> queue. We've discussed this before and looks like we need to introduce a\\n> timeout parameter to pg_cmdstatus()...\\n>\\n\\nI've added the timeout parameter to the pg_cmdstatus call, and more\\nimportantly to the sending side of the queue, so that one can limit the\\npotential effect of handling the interrupt in case something goes really\\nwrong.\\n\\nI've tested a number of possible scenarios with artificial delays in reply\\nand sending cancel request or SIGTERM to the receiving side and this is all\\nseems to work nicely due to proper message queue detach event\\nnotification. Still I think it helps to know that there is a timeout in\\ncase the receiving side is really slow to read the message.\\n\\nI've also decided we really ought to suppress any possible ERROR level\\nmessages generated during the course of processing the status request in\\norder not to prevent the originally running transaction to complete. The\\nerrors so caught are just logged using LOG level and ignored in this new\\nversion of the patch.\\n\\nI'm also submitting the instrumentation support as a separate patch on top\\nof this. I'm not really fond of adding bool parameter to InstrEndLoop, but\\nfor now I didn't find any better way.\\n\\nWhat I'm now thinking about is probably we can extend this backend\\ncommunication mechanism in order to query GUC values effective in a\\ndifferent backend or even setting the values. The obvious candidate to\\ncheck when you see some query misbehaving would be work_mem, for example.\\nOr we could provide a report of all settings that were overridden in the\\nbackend's session, to the effect of running something like this:\\n\\nselect * from pg_settings where context = 'user' and setting != reset_val;\\n\\nThe obvious candidates to be set externally are the\\ncmdstatus_analyze/instrument_*: when you decided you want to turn them on,\\nyou'd rather do that carefully for a single backend than globally\\nper-cluster. One can still modify the postgresql.conf and then send SIGHUP\\nto just a single backend, but I think a more direct way to alter the\\nsettings would be better.\\n\\nIn this light should we rename the API to something like \\\"backend control\\\"\\ninstead of \\\"command status\\\"? The SHOW/SET syntax could be extended to\\nsupport the remote setting retrieval/update.\\n\\n--\\nAlex\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Wed, 16 Sep 2015 16:31:47 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-16 16:31 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Tue, Sep 15, 2015 at 11:00 AM, Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de> wrote:\\n>\\n>> On Mon, Sep 14, 2015 at 7:27 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n>> wrote:\\n>>\\n>>>\\n>>> 2015-09-14 18:46 GMT+02:00 Shulgin, Oleksandr <\\n>>> oleksandr.shulgin@zalando.de>:\\n>>>\\n>>>>\\n>>>> ... This way the receiver only writes to the slot and the sender only\\n>>>> reads from it.\\n>>>>\\n>>>> By the way, is it safe to assume atomic read/writes of dsm_handle\\n>>>> (uint32)? I would be surprised if not.\\n>>>>\\n>>>\\n>>> I don't see any reason why it should not to work - only few processes\\n>>> will wait for data - so lost attach/detach shm operations will not be too\\n>>> much.\\n>>>\\n>>\\n>> Please see attached for implementation of this approach. The most\\n>> surprising thing is that it actually works :)\\n>>\\n>> One problem still remains with the process requesting information when\\n>> the target process exits before it can have a chance to handle the signal.\\n>> The requesting process then waits forever, because nobody attaches/detaches\\n>> the queue. We've discussed this before and looks like we need to introduce\\n>> a timeout parameter to pg_cmdstatus()...\\n>>\\n>\\n> I've added the timeout parameter to the pg_cmdstatus call, and more\\n> importantly to the sending side of the queue, so that one can limit the\\n> potential effect of handling the interrupt in case something goes really\\n> wrong.\\n>\\n\\nI don't think so introduction new user visible timer is good idea. This\\ntimer should be invisible\\n\\nMy idea - send a signal and wait 1sec, then check if target process is\\nliving still. Stop if not. Wait next 5 sec, then check target process. Stop\\nif this process doesn't live or raise warning \\\"requested process doesn't\\ncommunicate, waiting..\\\" The final cancel should be done by\\nstatement_timeout.\\n\\nwhat do you think about it?\\n\\n\\n>\\n> I've tested a number of possible scenarios with artificial delays in reply\\n> and sending cancel request or SIGTERM to the receiving side and this is all\\n> seems to work nicely due to proper message queue detach event\\n> notification. Still I think it helps to know that there is a timeout in\\n> case the receiving side is really slow to read the message.\\n>\\n> I've also decided we really ought to suppress any possible ERROR level\\n> messages generated during the course of processing the status request in\\n> order not to prevent the originally running transaction to complete. The\\n> errors so caught are just logged using LOG level and ignored in this new\\n> version of the patch.\\n>\\n> I'm also submitting the instrumentation support as a separate patch on top\\n> of this. I'm not really fond of adding bool parameter to InstrEndLoop, but\\n> for now I didn't find any better way.\\n>\\n> What I'm now thinking about is probably we can extend this backend\\n> communication mechanism in order to query GUC values effective in a\\n> different backend or even setting the values. The obvious candidate to\\n> check when you see some query misbehaving would be work_mem, for example.\\n> Or we could provide a report of all settings that were overridden in the\\n> backend's session, to the effect of running something like this:\\n>\\n> select * from pg_settings where context = 'user' and setting != reset_val;\\n>\\n\\nthis is a good idea. More times I interested what is current setting of\\nquery. We cannot to use simple query - because it is not possible to push\\nPID to function simply, but you can to write function pg_settings_pid() so\\nusage can look like\\n\\nselect * from pg_settings_pid(xxxx, possible other params) where ...\\n\\n\\n\\n>\\n> The obvious candidates to be set externally are the\\n> cmdstatus_analyze/instrument_*: when you decided you want to turn them on,\\n> you'd rather do that carefully for a single backend than globally\\n> per-cluster. One can still modify the postgresql.conf and then send SIGHUP\\n> to just a single backend, but I think a more direct way to alter the\\n> settings would be better.\\n>\\n\\nI am 100% for possibility to read the setting. But reconfiguration from\\nother process is too hot coffee - it can be available via extension, but\\nnot via usually used tools.\\n\\n\\n>\\n> In this light should we rename the API to something like \\\"backend control\\\"\\n> instead of \\\"command status\\\"? The SHOW/SET syntax could be extended to\\n> support the remote setting retrieval/update.\\n>\\n\\nprepare API, and this functionality can be part of referential\\nimplementation in contrib.\\n\\nThis patch should not to have too range be finished in this release cycle.\\n\\nRegards\\n\\nPavel\\n\\n\\n\\n\\n\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n2015-09-16 16:31 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Tue, Sep 15, 2015 at 11:00 AM, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote:On Mon, Sep 14, 2015 at 7:27 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-14 18:46 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:... This way the receiver only writes to the slot and the sender only reads from it.By the way, is it safe to assume atomic read/writes of dsm_handle (uint32)? I would be surprised if not.I don't see any reason why it should not to work - only few processes will wait for data - so lost attach/detach shm operations will not be too much. Please see attached for implementation of this approach. The most surprising thing is that it actually works :)One problem still remains with the process requesting information when the target process exits before it can have a chance to handle the signal. The requesting process then waits forever, because nobody attaches/detaches the queue. We've discussed this before and looks like we need to introduce a timeout parameter to pg_cmdstatus()...I've added the timeout parameter to the pg_cmdstatus call, and more importantly to the sending side of the queue, so that one can limit the potential effect of handling the interrupt in case something goes really wrong.I don't think so introduction new user visible timer is good idea. This timer should be invisible My idea - send a signal and wait 1sec, then check if target process is living still. Stop if not. Wait next 5 sec, then check target process. Stop if this process doesn't live or raise warning \\\"requested process doesn't communicate, waiting..\\\" The final cancel should be done by statement_timeout.what do you think about it? I've tested a number of possible scenarios with artificial delays in reply and sending cancel request or SIGTERM to the receiving side and this is all seems to work nicely due to proper message queue detach event notification. Still I think it helps to know that there is a timeout in case the receiving side is really slow to read the message.I've also decided we really ought to suppress any possible ERROR level messages generated during the course of processing the status request in order not to prevent the originally running transaction to complete. The errors so caught are just logged using LOG level and ignored in this new version of the patch.I'm also submitting the instrumentation support as a separate patch on top of this. I'm not really fond of adding bool parameter to InstrEndLoop, but for now I didn't find any better way.What I'm now thinking about is probably we can extend this backend communication mechanism in order to query GUC values effective in a different backend or even setting the values. The obvious candidate to check when you see some query misbehaving would be work_mem, for example. Or we could provide a report of all settings that were overridden in the backend's session, to the effect of running something like this:select * from pg_settings where context = 'user' and setting != reset_val;this is a good idea. More times I interested what is current setting of query. We cannot to use simple query - because it is not possible to push PID to function simply, but you can to write function pg_settings_pid() so usage can look likeselect * from pg_settings_pid(xxxx, possible other params) where ... The obvious candidates to be set externally are the cmdstatus_analyze/instrument_*: when you decided you want to turn them on, you'd rather do that carefully for a single backend than globally per-cluster. One can still modify the postgresql.conf and then send SIGHUP to just a single backend, but I think a more direct way to alter the settings would be better.I am 100% for possibility to read the setting. But reconfiguration from other process is too hot coffee - it can be available via extension, but not via usually used tools. In this light should we rename the API to something like \\\"backend control\\\" instead of \\\"command status\\\"? The SHOW/SET syntax could be extended to support the remote setting retrieval/update.prepare API, and this functionality can be part of referential implementation in contrib. This patch should not to have too range be finished in this release cycle.RegardsPavel --Alex\",\n \"msg_date\": \"Wed, 16 Sep 2015 20:07:14 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 16, 2015 at 8:07 PM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n\\n>\\n> 2015-09-16 16:31 GMT+02:00 Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de>:\\n>\\n>>\\n>> I've added the timeout parameter to the pg_cmdstatus call, and more\\n>> importantly to the sending side of the queue, so that one can limit the\\n>> potential effect of handling the interrupt in case something goes really\\n>> wrong.\\n>>\\n>\\n> I don't think so introduction new user visible timer is good idea. This\\n> timer should be invisible\\n>\\n> My idea - send a signal and wait 1sec, then check if target process is\\n> living still. Stop if not. Wait next 5 sec, then check target process. Stop\\n> if this process doesn't live or raise warning \\\"requested process doesn't\\n> communicate, waiting..\\\" The final cancel should be done by\\n> statement_timeout.\\n>\\n> what do you think about it?\\n>\\n\\nThat won't work really well with something like I use to do when testing\\nthis patch, namely:\\n\\npostgres=# select pid, array(select pg_cmdstatus(pid, 1, 10)) from\\npg_stat_activity where pid<>pg_backend_pid() \\\\watch 1\\n\\nwhile also running pgbench with -C option (to create new connection for\\nevery transaction). When a targeted backend exits before it can handle the\\nsignal, the receiving process keeps waiting forever.\\n\\nThe statement_timeout in this case will stop the whole select, not just\\nindividual function call. Unless you wrap it to set statement_timeout and\\ncatch QUERY_CANCELED in plpgsql, but then you won't be able to ^C the whole\\nselect. The ability to set a (short) timeout for the function itself\\nproves to be a really useful feature to me.\\n\\nWe can still communicate some warnings to the client when no timeout is\\nspecified (and make 0 the default value actually).\\n\\nWhat I'm now thinking about is probably we can extend this backend\\n>> communication mechanism in order to query GUC values effective in a\\n>> different backend or even setting the values. The obvious candidate to\\n>> check when you see some query misbehaving would be work_mem, for example.\\n>> Or we could provide a report of all settings that were overridden in the\\n>> backend's session, to the effect of running something like this:\\n>>\\n>> select * from pg_settings where context = 'user' and setting != reset_val;\\n>>\\n>\\n> this is a good idea. More times I interested what is current setting of\\n> query. We cannot to use simple query - because it is not possible to push\\n> PID to function simply, but you can to write function pg_settings_pid() so\\n> usage can look like\\n>\\n> select * from pg_settings_pid(xxxx, possible other params) where ...\\n>\\n\\nI would rather have a more general way to run *readonly* queries in the\\nother backend than invent a new function for every occurrence.\\n\\nThe obvious candidates to be set externally are the\\n>> cmdstatus_analyze/instrument_*: when you decided you want to turn them on,\\n>> you'd rather do that carefully for a single backend than globally\\n>> per-cluster. One can still modify the postgresql.conf and then send SIGHUP\\n>> to just a single backend, but I think a more direct way to alter the\\n>> settings would be better.\\n>>\\n>\\n> I am 100% for possibility to read the setting. But reconfiguration from\\n> other process is too hot coffee - it can be available via extension, but\\n> not via usually used tools.\\n>\\n\\nIt can be reserved to superuser, and nobody is forcing one to use it\\nanyway. :-)\\n\\nIn this light should we rename the API to something like \\\"backend control\\\"\\n>> instead of \\\"command status\\\"? The SHOW/SET syntax could be extended to\\n>> support the remote setting retrieval/update.\\n>>\\n>\\n> prepare API, and this functionality can be part of referential\\n> implementation in contrib.\\n>\\n> This patch should not to have too range be finished in this release cycle.\\n>\\n\\nThese are just the thoughts on what could be achieved using this\\ncross-backend communication mechanism and ideas for generalization of the\\nAPI.\\n\\n--\\nAlex\\n\\nOn Wed, Sep 16, 2015 at 8:07 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-16 16:31 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:I've added the timeout parameter to the pg_cmdstatus call, and more importantly to the sending side of the queue, so that one can limit the potential effect of handling the interrupt in case something goes really wrong.I don't think so introduction new user visible timer is good idea. This timer should be invisible My idea - send a signal and wait 1sec, then check if target process is living still. Stop if not. Wait next 5 sec, then check target process. Stop if this process doesn't live or raise warning \\\"requested process doesn't communicate, waiting..\\\" The final cancel should be done by statement_timeout.what do you think about it?That won't work really well with something like I use to do when testing this patch, namely:postgres=# select pid, array(select pg_cmdstatus(pid, 1, 10)) from pg_stat_activity where pid<>pg_backend_pid() \\\\watch 1while also running pgbench with -C option (to create new connection for every transaction). When a targeted backend exits before it can handle the signal, the receiving process keeps waiting forever.The statement_timeout in this case will stop the whole select, not just individual function call. Unless you wrap it to set statement_timeout and catch QUERY_CANCELED in plpgsql, but then you won't be able to ^C the whole select. The ability to set a (short) timeout for the function itself proves to be a really useful feature to me.We can still communicate some warnings to the client when no timeout is specified (and make 0 the default value actually).What I'm now thinking about is probably we can extend this backend communication mechanism in order to query GUC values effective in a different backend or even setting the values. The obvious candidate to check when you see some query misbehaving would be work_mem, for example. Or we could provide a report of all settings that were overridden in the backend's session, to the effect of running something like this:select * from pg_settings where context = 'user' and setting != reset_val;this is a good idea. More times I interested what is current setting of query. We cannot to use simple query - because it is not possible to push PID to function simply, but you can to write function pg_settings_pid() so usage can look likeselect * from pg_settings_pid(xxxx, possible other params) where ...I would rather have a more general way to run *readonly* queries in the other backend than invent a new function for every occurrence.The obvious candidates to be set externally are the cmdstatus_analyze/instrument_*: when you decided you want to turn them on, you'd rather do that carefully for a single backend than globally per-cluster. One can still modify the postgresql.conf and then send SIGHUP to just a single backend, but I think a more direct way to alter the settings would be better.I am 100% for possibility to read the setting. But reconfiguration from other process is too hot coffee - it can be available via extension, but not via usually used tools. It can be reserved to superuser, and nobody is forcing one to use it anyway. :-)In this light should we rename the API to something like \\\"backend control\\\" instead of \\\"command status\\\"? The SHOW/SET syntax could be extended to support the remote setting retrieval/update.prepare API, and this functionality can be part of referential implementation in contrib. This patch should not to have too range be finished in this release cycle.These are just the thoughts on what could be achieved using this cross-backend communication mechanism and ideas for generalization of the API.--Alex\",\n \"msg_date\": \"Thu, 17 Sep 2015 11:55:57 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-17 11:55 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Wed, Sep 16, 2015 at 8:07 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n>\\n>>\\n>> 2015-09-16 16:31 GMT+02:00 Shulgin, Oleksandr <\\n>> oleksandr.shulgin@zalando.de>:\\n>>\\n>>>\\n>>> I've added the timeout parameter to the pg_cmdstatus call, and more\\n>>> importantly to the sending side of the queue, so that one can limit the\\n>>> potential effect of handling the interrupt in case something goes really\\n>>> wrong.\\n>>>\\n>>\\n>> I don't think so introduction new user visible timer is good idea. This\\n>> timer should be invisible\\n>>\\n>> My idea - send a signal and wait 1sec, then check if target process is\\n>> living still. Stop if not. Wait next 5 sec, then check target process. Stop\\n>> if this process doesn't live or raise warning \\\"requested process doesn't\\n>> communicate, waiting..\\\" The final cancel should be done by\\n>> statement_timeout.\\n>>\\n>> what do you think about it?\\n>>\\n>\\n> That won't work really well with something like I use to do when testing\\n> this patch, namely:\\n>\\n> postgres=# select pid, array(select pg_cmdstatus(pid, 1, 10)) from\\n> pg_stat_activity where pid<>pg_backend_pid() \\\\watch 1\\n>\\n> while also running pgbench with -C option (to create new connection for\\n> every transaction). When a targeted backend exits before it can handle the\\n> signal, the receiving process keeps waiting forever.\\n>\\n\\nno - every timeout you have to check, if targeted backend is living still,\\nif not you will do cancel. It is 100% safe.\\n\\n\\n>\\n> The statement_timeout in this case will stop the whole select, not just\\n> individual function call. Unless you wrap it to set statement_timeout and\\n> catch QUERY_CANCELED in plpgsql, but then you won't be able to ^C the whole\\n> select. The ability to set a (short) timeout for the function itself\\n> proves to be a really useful feature to me.\\n>\\n\\nyou cannot to handle QUERY_CANCELED in plpgsql. There is need some internal\\ntimeout - but this timeout should not be visible - any new GUC increase\\nPostgreSQL complexity - and there is not a reason why do it.\\n\\n\\n>\\n> We can still communicate some warnings to the client when no timeout is\\n> specified (and make 0 the default value actually).\\n>\\n> What I'm now thinking about is probably we can extend this backend\\n>>> communication mechanism in order to query GUC values effective in a\\n>>> different backend or even setting the values. The obvious candidate to\\n>>> check when you see some query misbehaving would be work_mem, for example.\\n>>> Or we could provide a report of all settings that were overridden in the\\n>>> backend's session, to the effect of running something like this:\\n>>>\\n>>> select * from pg_settings where context = 'user' and setting !=\\n>>> reset_val;\\n>>>\\n>>\\n>> this is a good idea. More times I interested what is current setting of\\n>> query. We cannot to use simple query - because it is not possible to push\\n>> PID to function simply, but you can to write function pg_settings_pid() so\\n>> usage can look like\\n>>\\n>> select * from pg_settings_pid(xxxx, possible other params) where ...\\n>>\\n>\\n> I would rather have a more general way to run *readonly* queries in the\\n> other backend than invent a new function for every occurrence.\\n>\\n> The obvious candidates to be set externally are the\\n>>> cmdstatus_analyze/instrument_*: when you decided you want to turn them on,\\n>>> you'd rather do that carefully for a single backend than globally\\n>>> per-cluster. One can still modify the postgresql.conf and then send SIGHUP\\n>>> to just a single backend, but I think a more direct way to alter the\\n>>> settings would be better.\\n>>>\\n>>\\n>> I am 100% for possibility to read the setting. But reconfiguration from\\n>> other process is too hot coffee - it can be available via extension, but\\n>> not via usually used tools.\\n>>\\n>\\n> It can be reserved to superuser, and nobody is forcing one to use it\\n> anyway. :-)\\n>\\n> In this light should we rename the API to something like \\\"backend control\\\"\\n>>> instead of \\\"command status\\\"? The SHOW/SET syntax could be extended to\\n>>> support the remote setting retrieval/update.\\n>>>\\n>>\\n>> prepare API, and this functionality can be part of referential\\n>> implementation in contrib.\\n>>\\n>> This patch should not to have too range be finished in this release cycle.\\n>>\\n>\\n> These are just the thoughts on what could be achieved using this\\n> cross-backend communication mechanism and ideas for generalization of the\\n> API.\\n>\\n\\nok\\n\\n\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n2015-09-17 11:55 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Wed, Sep 16, 2015 at 8:07 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-16 16:31 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:I've added the timeout parameter to the pg_cmdstatus call, and more importantly to the sending side of the queue, so that one can limit the potential effect of handling the interrupt in case something goes really wrong.I don't think so introduction new user visible timer is good idea. This timer should be invisible My idea - send a signal and wait 1sec, then check if target process is living still. Stop if not. Wait next 5 sec, then check target process. Stop if this process doesn't live or raise warning \\\"requested process doesn't communicate, waiting..\\\" The final cancel should be done by statement_timeout.what do you think about it?That won't work really well with something like I use to do when testing this patch, namely:postgres=# select pid, array(select pg_cmdstatus(pid, 1, 10)) from pg_stat_activity where pid<>pg_backend_pid() \\\\watch 1while also running pgbench with -C option (to create new connection for every transaction). When a targeted backend exits before it can handle the signal, the receiving process keeps waiting forever.no - every timeout you have to check, if targeted backend is living still, if not you will do cancel. It is 100% safe. The statement_timeout in this case will stop the whole select, not just individual function call. Unless you wrap it to set statement_timeout and catch QUERY_CANCELED in plpgsql, but then you won't be able to ^C the whole select. The ability to set a (short) timeout for the function itself proves to be a really useful feature to me.you cannot to handle QUERY_CANCELED in plpgsql. There is need some internal timeout - but this timeout should not be visible - any new GUC increase PostgreSQL complexity - and there is not a reason why do it. We can still communicate some warnings to the client when no timeout is specified (and make 0 the default value actually).What I'm now thinking about is probably we can extend this backend communication mechanism in order to query GUC values effective in a different backend or even setting the values. The obvious candidate to check when you see some query misbehaving would be work_mem, for example. Or we could provide a report of all settings that were overridden in the backend's session, to the effect of running something like this:select * from pg_settings where context = 'user' and setting != reset_val;this is a good idea. More times I interested what is current setting of query. We cannot to use simple query - because it is not possible to push PID to function simply, but you can to write function pg_settings_pid() so usage can look likeselect * from pg_settings_pid(xxxx, possible other params) where ...I would rather have a more general way to run *readonly* queries in the other backend than invent a new function for every occurrence.The obvious candidates to be set externally are the cmdstatus_analyze/instrument_*: when you decided you want to turn them on, you'd rather do that carefully for a single backend than globally per-cluster. One can still modify the postgresql.conf and then send SIGHUP to just a single backend, but I think a more direct way to alter the settings would be better.I am 100% for possibility to read the setting. But reconfiguration from other process is too hot coffee - it can be available via extension, but not via usually used tools. It can be reserved to superuser, and nobody is forcing one to use it anyway. :-)In this light should we rename the API to something like \\\"backend control\\\" instead of \\\"command status\\\"? The SHOW/SET syntax could be extended to support the remote setting retrieval/update.prepare API, and this functionality can be part of referential implementation in contrib. This patch should not to have too range be finished in this release cycle.These are just the thoughts on what could be achieved using this cross-backend communication mechanism and ideas for generalization of the API.ok --Alex\",\n \"msg_date\": \"Thu, 17 Sep 2015 12:06:09 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 15, 2015 at 5:00 AM, Shulgin, Oleksandr\\n<oleksandr.shulgin@zalando.de> wrote:\\n> Please see attached for implementation of this approach. The most\\n> surprising thing is that it actually works :)\\n\\nIt's cool to see these interesting ideas for using some of the code\\nI've been working on for the last couple of years. However, it seems\\nto me that a better design would avoid the use of shm_mq. Instead of\\nhaving the guy who asks the question create a DSM, have the guy who\\nsends back the answer create it. Then, he can just make the DSM big\\nenough to store the entire string. I think that's going to be a lot\\nmore robust than what you have here.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 17 Sep 2015 08:06:53 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 16, 2015 at 10:31 AM, Shulgin, Oleksandr\\n<oleksandr.shulgin@zalando.de> wrote:\\n> I've also decided we really ought to suppress any possible ERROR level\\n> messages generated during the course of processing the status request in\\n> order not to prevent the originally running transaction to complete. The\\n> errors so caught are just logged using LOG level and ignored in this new\\n> version of the patch.\\n\\nThis plan has almost zero chance of surviving committer-level\\nscrutiny, and if it somehow does, some other committer will scream\\nbloody murder as soon as they notice it.\\n\\nIt's not safe to just catch an error and continue on executing. You\\nhave to abort the (sub)transaction once an error happens.\\n\\nOf course, this gets at a pretty crucial design question for this\\npatch, which is whether it's OK for one process to interrogate another\\nprocess's state, and what the consequences of that might be. What\\npermissions are needed? Can you DOS the guy running a query by\\npinging him for status at a very high rate?\\n\\nThe other question here is whether it's really safe to do this.\\nProcessInterrupts() gets called at lots of places in the code, and we\\nmay freely add more in the future. How are you going to prove that\\nProcessCmdStatusInfoRequest() is safe to call in all of those places?\\nHow do you know that some data structure you find by chasing down from\\nActivePortal or current_query_stack doesn't have a NULL pointer\\nsomeplace that you don't expect, because the code that initializes\\nthat pointer hasn't run yet?\\n\\nI'd like to see this made to work and be safe, but I think proving\\nthat it's truly robust in all cases is going to be hard.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 17 Sep 2015 08:14:05 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 17, 2015 at 12:06 PM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n\\n>\\n>> That won't work really well with something like I use to do when testing\\n>> this patch, namely:\\n>>\\n>> postgres=# select pid, array(select pg_cmdstatus(pid, 1, 10)) from\\n>> pg_stat_activity where pid<>pg_backend_pid() \\\\watch 1\\n>>\\n>> while also running pgbench with -C option (to create new connection for\\n>> every transaction). When a targeted backend exits before it can handle the\\n>> signal, the receiving process keeps waiting forever.\\n>>\\n>\\n> no - every timeout you have to check, if targeted backend is living still,\\n> if not you will do cancel. It is 100% safe.\\n>\\n\\nBut then you need to make this internal timeout rather short, not 1s as\\noriginally suggested.\\n\\nThe statement_timeout in this case will stop the whole select, not just\\n>> individual function call. Unless you wrap it to set statement_timeout and\\n>> catch QUERY_CANCELED in plpgsql, but then you won't be able to ^C the whole\\n>> select. The ability to set a (short) timeout for the function itself\\n>> proves to be a really useful feature to me.\\n>>\\n>\\n> you cannot to handle QUERY_CANCELED in plpgsql.\\n>\\n\\nWell, you can but its not that useful of course:\\n\\n=# create or replace function test_query_cancel() returns void language\\nplpgsql as $$ begin\\n perform pg_sleep(1);\\n exception when query_canceled then raise notice 'cancel';\\nend; $$;\\nCREATE FUNCTION\\n=# set statement_timeout to '100ms';\\nSET\\n=# select test_query_cancel();\\nNOTICE: cancel\\n test_query_cancel\\n-------------------\\n\\n(1 row)\\n=# select test_query_cancel() from generate_series(1, 100) x;\\nNOTICE: cancel\\n^CCancel request sent\\nNOTICE: cancel\\n^CCancel request sent\\n\\nNow you cannot cancel this query unless you do pg_terminate_backend() or\\nequivalent.\\n\\nThere is need some internal timeout - but this timeout should not be\\n> visible - any new GUC increase PostgreSQL complexity - and there is not a\\n> reason why do it.\\n>\\n\\nBut the GUC was added for the timeout on the sending side, not the\\nreceiving one. There is no \\\"one value fits all\\\" for this, but you would\\nstill want to make the effects of this as limited as possible.\\n\\n--\\nAlex\\n\\nOn Thu, Sep 17, 2015 at 12:06 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:That won't work really well with something like I use to do when testing this patch, namely:postgres=# select pid, array(select pg_cmdstatus(pid, 1, 10)) from pg_stat_activity where pid<>pg_backend_pid() \\\\watch 1while also running pgbench with -C option (to create new connection for every transaction). When a targeted backend exits before it can handle the signal, the receiving process keeps waiting forever.no - every timeout you have to check, if targeted backend is living still, if not you will do cancel. It is 100% safe.But then you need to make this internal timeout rather short, not 1s as originally suggested.The statement_timeout in this case will stop the whole select, not just individual function call. Unless you wrap it to set statement_timeout and catch QUERY_CANCELED in plpgsql, but then you won't be able to ^C the whole select. The ability to set a (short) timeout for the function itself proves to be a really useful feature to me.you cannot to handle QUERY_CANCELED in plpgsql.Well, you can but its not that useful of course:=# create or replace function test_query_cancel() returns void language plpgsql as $$ begin perform pg_sleep(1); exception when query_canceled then raise notice 'cancel';end; $$; CREATE FUNCTION=# set statement_timeout to '100ms';SET=# select test_query_cancel();NOTICE: cancel test_query_cancel ------------------- (1 row)=# select test_query_cancel() from generate_series(1, 100) x;NOTICE: cancel^CCancel request sentNOTICE: cancel^CCancel request sentNow you cannot cancel this query unless you do pg_terminate_backend() or equivalent. There is need some internal timeout - but this timeout should not be visible - any new GUC increase PostgreSQL complexity - and there is not a reason why do it. But the GUC was added for the timeout on the sending side, not the receiving one. There is no \\\"one value fits all\\\" for this, but you would still want to make the effects of this as limited as possible.--Alex\",\n \"msg_date\": \"Thu, 17 Sep 2015 16:06:01 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-17 14:06 GMT+02:00 Robert Haas <robertmhaas@gmail.com>:\\n\\n> On Tue, Sep 15, 2015 at 5:00 AM, Shulgin, Oleksandr\\n> <oleksandr.shulgin@zalando.de> wrote:\\n> > Please see attached for implementation of this approach. The most\\n> > surprising thing is that it actually works :)\\n>\\n> It's cool to see these interesting ideas for using some of the code\\n> I've been working on for the last couple of years. However, it seems\\n> to me that a better design would avoid the use of shm_mq. Instead of\\n> having the guy who asks the question create a DSM, have the guy who\\n> sends back the answer create it. Then, he can just make the DSM big\\n> enough to store the entire string. I think that's going to be a lot\\n> more robust than what you have here.\\n>\\n\\nPlease, can you explain what is wrong on using of shm_mq? It works pretty\\nwell now.\\n\\nThere can be a contra argument, why don't use shm_mq, because it does data\\nexchange between processes and this patch introduce new pattern for same\\nthing.\\n\\nRegards\\n\\nPavel\\n\\n\\n>\\n> --\\n> Robert Haas\\n> EnterpriseDB: http://www.enterprisedb.com\\n> The Enterprise PostgreSQL Company\\n>\\n\\n2015-09-17 14:06 GMT+02:00 Robert Haas <robertmhaas@gmail.com>:On Tue, Sep 15, 2015 at 5:00 AM, Shulgin, Oleksandr\\n<oleksandr.shulgin@zalando.de> wrote:\\n> Please see attached for implementation of this approach. The most\\n> surprising thing is that it actually works :)\\n\\nIt's cool to see these interesting ideas for using some of the code\\nI've been working on for the last couple of years. However, it seems\\nto me that a better design would avoid the use of shm_mq. Instead of\\nhaving the guy who asks the question create a DSM, have the guy who\\nsends back the answer create it. Then, he can just make the DSM big\\nenough to store the entire string. I think that's going to be a lot\\nmore robust than what you have here.Please, can you explain what is wrong on using of shm_mq? It works pretty well now. There can be a contra argument, why don't use shm_mq, because it does data exchange between processes and this patch introduce new pattern for same thing.RegardsPavel \\n\\n--\\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\",\n \"msg_date\": \"Thu, 17 Sep 2015 16:28:53 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-17 16:06 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Thu, Sep 17, 2015 at 12:06 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n>\\n>>\\n>>> That won't work really well with something like I use to do when testing\\n>>> this patch, namely:\\n>>>\\n>>> postgres=# select pid, array(select pg_cmdstatus(pid, 1, 10)) from\\n>>> pg_stat_activity where pid<>pg_backend_pid() \\\\watch 1\\n>>>\\n>>> while also running pgbench with -C option (to create new connection for\\n>>> every transaction). When a targeted backend exits before it can handle the\\n>>> signal, the receiving process keeps waiting forever.\\n>>>\\n>>\\n>> no - every timeout you have to check, if targeted backend is living\\n>> still, if not you will do cancel. It is 100% safe.\\n>>\\n>\\n> But then you need to make this internal timeout rather short, not 1s as\\n> originally suggested.\\n>\\n\\ncan be - 1 sec is max, maybe 100ms is optimum.\\n\\n>\\n> The statement_timeout in this case will stop the whole select, not just\\n>>> individual function call. Unless you wrap it to set statement_timeout and\\n>>> catch QUERY_CANCELED in plpgsql, but then you won't be able to ^C the whole\\n>>> select. The ability to set a (short) timeout for the function itself\\n>>> proves to be a really useful feature to me.\\n>>>\\n>>\\n>> you cannot to handle QUERY_CANCELED in plpgsql.\\n>>\\n>\\n> Well, you can but its not that useful of course:\\n>\\n\\nhmm, some is wrong - I remember from some older plpgsql, so CANCEL message\\nis not catchable. Maybe I have bad memory. I have to recheck it.\\n\\n\\n>\\n> =# create or replace function test_query_cancel() returns void language\\n> plpgsql as $$ begin\\n> perform pg_sleep(1);\\n> exception when query_canceled then raise notice 'cancel';\\n> end; $$;\\n> CREATE FUNCTION\\n> =# set statement_timeout to '100ms';\\n> SET\\n> =# select test_query_cancel();\\n> NOTICE: cancel\\n> test_query_cancel\\n> -------------------\\n>\\n> (1 row)\\n> =# select test_query_cancel() from generate_series(1, 100) x;\\n> NOTICE: cancel\\n> ^CCancel request sent\\n> NOTICE: cancel\\n> ^CCancel request sent\\n>\\n> Now you cannot cancel this query unless you do pg_terminate_backend() or\\n> equivalent.\\n>\\n> There is need some internal timeout - but this timeout should not be\\n>> visible - any new GUC increase PostgreSQL complexity - and there is not a\\n>> reason why do it.\\n>>\\n>\\n> But the GUC was added for the timeout on the sending side, not the\\n> receiving one. There is no \\\"one value fits all\\\" for this, but you would\\n> still want to make the effects of this as limited as possible.\\n>\\n\\nI still believe so any new GUC is not necessary. If you don't like\\nstatement_timeout, we can copy the behave of CREATE DATABASE - there are\\nfew 5sec cycles (when template1 is occupated) and break.\\n\\nRegards\\n\\nPavel\\n\\n\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n2015-09-17 16:06 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Thu, Sep 17, 2015 at 12:06 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:That won't work really well with something like I use to do when testing this patch, namely:postgres=# select pid, array(select pg_cmdstatus(pid, 1, 10)) from pg_stat_activity where pid<>pg_backend_pid() \\\\watch 1while also running pgbench with -C option (to create new connection for every transaction). When a targeted backend exits before it can handle the signal, the receiving process keeps waiting forever.no - every timeout you have to check, if targeted backend is living still, if not you will do cancel. It is 100% safe.But then you need to make this internal timeout rather short, not 1s as originally suggested.can be - 1 sec is max, maybe 100ms is optimum. The statement_timeout in this case will stop the whole select, not just individual function call. Unless you wrap it to set statement_timeout and catch QUERY_CANCELED in plpgsql, but then you won't be able to ^C the whole select. The ability to set a (short) timeout for the function itself proves to be a really useful feature to me.you cannot to handle QUERY_CANCELED in plpgsql.Well, you can but its not that useful of course:hmm, some is wrong - I remember from some older plpgsql, so CANCEL message is not catchable. Maybe I have bad memory. I have to recheck it. =# create or replace function test_query_cancel() returns void language plpgsql as $$ begin perform pg_sleep(1); exception when query_canceled then raise notice 'cancel';end; $$; CREATE FUNCTION=# set statement_timeout to '100ms';SET=# select test_query_cancel();NOTICE: cancel test_query_cancel ------------------- (1 row)=# select test_query_cancel() from generate_series(1, 100) x;NOTICE: cancel^CCancel request sentNOTICE: cancel^CCancel request sentNow you cannot cancel this query unless you do pg_terminate_backend() or equivalent. There is need some internal timeout - but this timeout should not be visible - any new GUC increase PostgreSQL complexity - and there is not a reason why do it. But the GUC was added for the timeout on the sending side, not the receiving one. There is no \\\"one value fits all\\\" for this, but you would still want to make the effects of this as limited as possible.I still believe so any new GUC is not necessary. If you don't like statement_timeout, we can copy the behave of CREATE DATABASE - there are few 5sec cycles (when template1 is occupated) and break.RegardsPavel --Alex\",\n \"msg_date\": \"Thu, 17 Sep 2015 16:37:06 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 17, 2015 at 10:28 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:\\n> Please, can you explain what is wrong on using of shm_mq? It works pretty\\n> well now.\\n>\\n> There can be a contra argument, why don't use shm_mq, because it does data\\n> exchange between processes and this patch introduce new pattern for same\\n> thing.\\n\\nSure, I can explain that.\\n\\nFirst, when you communication through a shm_mq, the writer has to wait\\nwhen the queue is full, and the reader has to wait when the queue is\\nempty. If the message is short enough to fit in the queue, then you\\ncan send it and be done without blocking. But if it is long, then you\\nwill have each process repeatedly waiting for the other one until the\\nwhole message has been sent. That is going to make sending the\\nmessage potentially a lot slower than writing it all in one go,\\nespecially if the system is under heavy load.\\n\\nAlso, if there are any bugs in the way the shm_mq is being used,\\nthey're likely to be quite rare and hard to find, because the vast\\nmajority of messages will probably be short enough to be sent in a\\nsingle chunk, so whatever bugs may exist when the processes play\\nping-ping are unlikely to occur in practice except in unusual cases\\nwhere the message being returned is very long.\\n\\nSecond, using a shm_mq manipulates the state of the process latch. I\\ndon't think you can make the assumption that it's safe to reset the\\nprocess latch at any and every place where we check for interrupts.\\nFor example, suppose the process is already using a shm_mq and the\\nCHECK_FOR_INTERRUPTS() call inside that code then discovers that\\nsomebody has activated this mechanism and you now go try to send and\\nreceive from a new shm_mq. But even if that and every other\\nCHECK_FOR_INTERRUPTS() in the code can tolerate a process latch reset\\ntoday, it's a new coding rule that could easily trip people up in the\\nfuture.\\n\\nUsing a shm_mq is appropriate when the amount of data that needs to be\\ntransmitted might be very large - too large to just allocate a buffer\\nfor the whole thing - or when the amount of data can't be predicted\\nbefore memory is allocated. But there is obviously no rule that a\\nshm_mq should be used any time we have \\\"data exchange between\\nprocesses\\\"; we have lots of shared-memory based IPC already and have\\nfor many years, and shm_mq is newer than the vast majority of that\\ncode.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 17 Sep 2015 10:46:55 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-17 16:46 GMT+02:00 Robert Haas <robertmhaas@gmail.com>:\\n\\n> On Thu, Sep 17, 2015 at 10:28 AM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n> > Please, can you explain what is wrong on using of shm_mq? It works pretty\\n> > well now.\\n> >\\n> > There can be a contra argument, why don't use shm_mq, because it does\\n> data\\n> > exchange between processes and this patch introduce new pattern for same\\n> > thing.\\n>\\n> Sure, I can explain that.\\n>\\n> First, when you communication through a shm_mq, the writer has to wait\\n> when the queue is full, and the reader has to wait when the queue is\\n> empty. If the message is short enough to fit in the queue, then you\\n> can send it and be done without blocking. But if it is long, then you\\n> will have each process repeatedly waiting for the other one until the\\n> whole message has been sent. That is going to make sending the\\n> message potentially a lot slower than writing it all in one go,\\n> especially if the system is under heavy load.\\n>\\n\\n\\nIs there some risk if we take too much large DSM segment? And what is max\\nsize of DSM segment? When we use shm_mq, we don't need to solve limits.\\n\\n\\n>\\n> Also, if there are any bugs in the way the shm_mq is being used,\\n> they're likely to be quite rare and hard to find, because the vast\\n> majority of messages will probably be short enough to be sent in a\\n> single chunk, so whatever bugs may exist when the processes play\\n> ping-ping are unlikely to occur in practice except in unusual cases\\n> where the message being returned is very long.\\n>\\n\\nThis is true for any functionality based on shm_mq - parallel seq scan,\\n\\n\\n>\\n> Second, using a shm_mq manipulates the state of the process latch. I\\n> don't think you can make the assumption that it's safe to reset the\\n> process latch at any and every place where we check for interrupts.\\n> For example, suppose the process is already using a shm_mq and the\\n> CHECK_FOR_INTERRUPTS() call inside that code then discovers that\\n> somebody has activated this mechanism and you now go try to send and\\n> receive from a new shm_mq. But even if that and every other\\n> CHECK_FOR_INTERRUPTS() in the code can tolerate a process latch reset\\n> today, it's a new coding rule that could easily trip people up in the\\n> future.\\n>\\n>\\nIt is valid, and probably most important. But if we introduce own\\nmechanism, we will play with process latch too (although we can use LWlocks)\\n\\n\\n> Using a shm_mq is appropriate when the amount of data that needs to be\\n> transmitted might be very large - too large to just allocate a buffer\\n> for the whole thing - or when the amount of data can't be predicted\\n> before memory is allocated. But there is obviously no rule that a\\n> shm_mq should be used any time we have \\\"data exchange between\\n> processes\\\"; we have lots of shared-memory based IPC already and have\\n> for many years, and shm_mq is newer than the vast majority of that\\n> code.\\n>\\n\\nI am little bit disappointed - I hoped so shm_mq can be used as generic\\ninterprocess mechanism - that will ensure all corner cases for work with\\nshared memory. I understand to shm_mq is new, and nobody used it, but this\\nrisk is better than invent wheels again and again.\\n\\nRegards\\n\\nPavel\\n\\n\\n> --\\n> Robert Haas\\n> EnterpriseDB: http://www.enterprisedb.com\\n> The Enterprise PostgreSQL Company\\n>\\n\\n2015-09-17 16:46 GMT+02:00 Robert Haas <robertmhaas@gmail.com>:On Thu, Sep 17, 2015 at 10:28 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:\\n> Please, can you explain what is wrong on using of shm_mq? It works pretty\\n> well now.\\n>\\n> There can be a contra argument, why don't use shm_mq, because it does data\\n> exchange between processes and this patch introduce new pattern for same\\n> thing.\\n\\nSure, I can explain that.\\n\\nFirst, when you communication through a shm_mq, the writer has to wait\\nwhen the queue is full, and the reader has to wait when the queue is\\nempty. If the message is short enough to fit in the queue, then you\\ncan send it and be done without blocking. But if it is long, then you\\nwill have each process repeatedly waiting for the other one until the\\nwhole message has been sent. That is going to make sending the\\nmessage potentially a lot slower than writing it all in one go,\\nespecially if the system is under heavy load.Is there some risk if we take too much large DSM segment? And what is max size of DSM segment? When we use shm_mq, we don't need to solve limits. \\n\\nAlso, if there are any bugs in the way the shm_mq is being used,\\nthey're likely to be quite rare and hard to find, because the vast\\nmajority of messages will probably be short enough to be sent in a\\nsingle chunk, so whatever bugs may exist when the processes play\\nping-ping are unlikely to occur in practice except in unusual cases\\nwhere the message being returned is very long.This is true for any functionality based on shm_mq - parallel seq scan, \\n\\nSecond, using a shm_mq manipulates the state of the process latch. I\\ndon't think you can make the assumption that it's safe to reset the\\nprocess latch at any and every place where we check for interrupts.\\nFor example, suppose the process is already using a shm_mq and the\\nCHECK_FOR_INTERRUPTS() call inside that code then discovers that\\nsomebody has activated this mechanism and you now go try to send and\\nreceive from a new shm_mq. But even if that and every other\\nCHECK_FOR_INTERRUPTS() in the code can tolerate a process latch reset\\ntoday, it's a new coding rule that could easily trip people up in the\\nfuture.\\nIt is valid, and probably most important. But if we introduce own mechanism, we will play with process latch too (although we can use LWlocks) \\nUsing a shm_mq is appropriate when the amount of data that needs to be\\ntransmitted might be very large - too large to just allocate a buffer\\nfor the whole thing - or when the amount of data can't be predicted\\nbefore memory is allocated. But there is obviously no rule that a\\nshm_mq should be used any time we have \\\"data exchange between\\nprocesses\\\"; we have lots of shared-memory based IPC already and have\\nfor many years, and shm_mq is newer than the vast majority of that\\ncode.I am little bit disappointed - I hoped so shm_mq can be used as generic interprocess mechanism - that will ensure all corner cases for work with shared memory. I understand to shm_mq is new, and nobody used it, but this risk is better than invent wheels again and again.RegardsPavel \\n\\n--\\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\",\n \"msg_date\": \"Thu, 17 Sep 2015 17:16:32 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 17, 2015 at 2:14 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n\\n> On Wed, Sep 16, 2015 at 10:31 AM, Shulgin, Oleksandr\\n> <oleksandr.shulgin@zalando.de> wrote:\\n> > I've also decided we really ought to suppress any possible ERROR level\\n> > messages generated during the course of processing the status request in\\n> > order not to prevent the originally running transaction to complete. The\\n> > errors so caught are just logged using LOG level and ignored in this new\\n> > version of the patch.\\n>\\n> This plan has almost zero chance of surviving committer-level\\n> scrutiny, and if it somehow does, some other committer will scream\\n> bloody murder as soon as they notice it.\\n>\\n> It's not safe to just catch an error and continue on executing. You\\n> have to abort the (sub)transaction once an error happens.\\n>\\n\\nHm... is this really different from WHEN EXCEPTION clause in plpgsql?\\n\\nOf course, this gets at a pretty crucial design question for this\\n> patch, which is whether it's OK for one process to interrogate another\\n> process's state, and what the consequences of that might be. What\\n> permissions are needed?\\n\\n\\nI think superuser or same user is pretty reasonable requirement. Can be\\nlimited to superuser only if there are some specific concerns.\\n\\nCan you DOS the guy running a query by\\n> pinging him for status at a very high rate?\\n>\\n\\nProbably, but if you've got enough permissions to do that\\npg_cancel/terminate_backend() would be easier.\\n\\nThe other question here is whether it's really safe to do this.\\n> ProcessInterrupts() gets called at lots of places in the code, and we\\n> may freely add more in the future. How are you going to prove that\\n> ProcessCmdStatusInfoRequest() is safe to call in all of those places?\\n> How do you know that some data structure you find by chasing down from\\n> ActivePortal or current_query_stack doesn't have a NULL pointer\\n> someplace that you don't expect, because the code that initializes\\n> that pointer hasn't run yet?\\n>\\n> I'd like to see this made to work and be safe, but I think proving\\n> that it's truly robust in all cases is going to be hard.\\n>\\n\\nYes, this is a perfectly good point. For the purpose of obtaining the\\nexplain plans, I believe anything we capture in ExecutorRun ought to be\\nsafe to run Explain on: the plannedstmt is there and isn't going to change.\\n\\nIn a more general case, if we seek to extend this approach, then yes one\\nshould be very careful in what is allowed to run during ProcessInterrupts().\\n\\nWhat we could do instead to be extra-safe, is make the running backend\\nprepare the information for other backends to obtain from the shared\\nmemory. Explain plans can be easily captured at the ExecutorRun hook. The\\nobvious downside is that you can no longer choose the explain format, or\\nobtain partially collected instrumentation data.\\n\\n--\\nAlex\\n\\nOn Thu, Sep 17, 2015 at 2:14 PM, Robert Haas <robertmhaas@gmail.com> wrote:On Wed, Sep 16, 2015 at 10:31 AM, Shulgin, Oleksandr\\n<oleksandr.shulgin@zalando.de> wrote:\\n> I've also decided we really ought to suppress any possible ERROR level\\n> messages generated during the course of processing the status request in\\n> order not to prevent the originally running transaction to complete. The\\n> errors so caught are just logged using LOG level and ignored in this new\\n> version of the patch.\\n\\nThis plan has almost zero chance of surviving committer-level\\nscrutiny, and if it somehow does, some other committer will scream\\nbloody murder as soon as they notice it.\\n\\nIt's not safe to just catch an error and continue on executing. You\\nhave to abort the (sub)transaction once an error happens.Hm... is this really different from WHEN EXCEPTION clause in plpgsql?\\nOf course, this gets at a pretty crucial design question for this\\npatch, which is whether it's OK for one process to interrogate another\\nprocess's state, and what the consequences of that might be. What\\npermissions are needed?I think superuser or same user is pretty reasonable requirement. Can be limited to superuser only if there are some specific concerns.Can you DOS the guy running a query by\\npinging him for status at a very high rate?Probably, but if you've got enough permissions to do that pg_cancel/terminate_backend() would be easier.\\nThe other question here is whether it's really safe to do this.\\nProcessInterrupts() gets called at lots of places in the code, and we\\nmay freely add more in the future. How are you going to prove that\\nProcessCmdStatusInfoRequest() is safe to call in all of those places?\\nHow do you know that some data structure you find by chasing down from\\nActivePortal or current_query_stack doesn't have a NULL pointer\\nsomeplace that you don't expect, because the code that initializes\\nthat pointer hasn't run yet?\\n\\nI'd like to see this made to work and be safe, but I think proving\\nthat it's truly robust in all cases is going to be hard.Yes, this is a perfectly good point. For the purpose of obtaining the explain plans, I believe anything we capture in ExecutorRun ought to be safe to run Explain on: the plannedstmt is there and isn't going to change.In a more general case, if we seek to extend this approach, then yes one should be very careful in what is allowed to run during ProcessInterrupts().What we could do instead to be extra-safe, is make the running backend prepare the information for other backends to obtain from the shared memory. Explain plans can be easily captured at the ExecutorRun hook. The obvious downside is that you can no longer choose the explain format, or obtain partially collected instrumentation data.--Alex\",\n \"msg_date\": \"Thu, 17 Sep 2015 17:30:34 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 17, 2015 at 5:16 PM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n\\n> 2015-09-17 16:46 GMT+02:00 Robert Haas <robertmhaas@gmail.com>:\\n>\\n>>\\n>> Second, using a shm_mq manipulates the state of the process latch. I\\n>> don't think you can make the assumption that it's safe to reset the\\n>> process latch at any and every place where we check for interrupts.\\n>> For example, suppose the process is already using a shm_mq and the\\n>> CHECK_FOR_INTERRUPTS() call inside that code then discovers that\\n>> somebody has activated this mechanism and you now go try to send and\\n>> receive from a new shm_mq. But even if that and every other\\n>> CHECK_FOR_INTERRUPTS() in the code can tolerate a process latch reset\\n>> today, it's a new coding rule that could easily trip people up in the\\n>> future.\\n>>\\n>\\n> It is valid, and probably most important. But if we introduce own\\n> mechanism, we will play with process latch too (although we can use LWlocks)\\n>\\n\\nCareful manipulation of the process latch is a valid point. Probably we\\nwere way too optimistic about the limits we can hit with this approach. :-(\\n\\nBut if we make the sender backend create the DSM with the response payload,\\nit suddenly becomes really unclear at which point and who should make the\\nfinal detach of that DSM. We're getting back to the problem of\\nsynchronization between these processes all over again.\\n\\n--\\nAlex\\n\\nOn Thu, Sep 17, 2015 at 5:16 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-17 16:46 GMT+02:00 Robert Haas <robertmhaas@gmail.com>:\\nSecond, using a shm_mq manipulates the state of the process latch. I\\ndon't think you can make the assumption that it's safe to reset the\\nprocess latch at any and every place where we check for interrupts.\\nFor example, suppose the process is already using a shm_mq and the\\nCHECK_FOR_INTERRUPTS() call inside that code then discovers that\\nsomebody has activated this mechanism and you now go try to send and\\nreceive from a new shm_mq. But even if that and every other\\nCHECK_FOR_INTERRUPTS() in the code can tolerate a process latch reset\\ntoday, it's a new coding rule that could easily trip people up in the\\nfuture.It is valid, and probably most important. But if we introduce own mechanism, we will play with process latch too (although we can use LWlocks)Careful manipulation of the process latch is a valid point. Probably we were way too optimistic about the limits we can hit with this approach. :-(But if we make the sender backend create the DSM with the response payload, it suddenly becomes really unclear at which point and who should make the final detach of that DSM. We're getting back to the problem of synchronization between these processes all over again.--Alex\",\n \"msg_date\": \"Thu, 17 Sep 2015 18:47:42 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 17, 2015 at 11:16 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:\\n> Is there some risk if we take too much large DSM segment? And what is max\\n> size of DSM segment? When we use shm_mq, we don't need to solve limits.\\n\\nI can't really think you are going to have a problem. How much data\\ndo you really intend to send back? Surely it's going to be <100kB.\\nIf you think it's not a problem to have a running query stop and send\\na gigabyte of data someplace anytime somebody asks, well, I don't\\nthink I agree.\\n\\n>> Also, if there are any bugs in the way the shm_mq is being used,\\n>> they're likely to be quite rare and hard to find, because the vast\\n>> majority of messages will probably be short enough to be sent in a\\n>> single chunk, so whatever bugs may exist when the processes play\\n>> ping-ping are unlikely to occur in practice except in unusual cases\\n>> where the message being returned is very long.\\n>\\n> This is true for any functionality based on shm_mq - parallel seq scan,\\n\\nParallel sequential scan is likely to put a lot more data through a\\nshm_mq than you would for this.\\n\\n>> Second, using a shm_mq manipulates the state of the process latch. I\\n>> don't think you can make the assumption that it's safe to reset the\\n>> process latch at any and every place where we check for interrupts.\\n>> For example, suppose the process is already using a shm_mq and the\\n>> CHECK_FOR_INTERRUPTS() call inside that code then discovers that\\n>> somebody has activated this mechanism and you now go try to send and\\n>> receive from a new shm_mq. But even if that and every other\\n>> CHECK_FOR_INTERRUPTS() in the code can tolerate a process latch reset\\n>> today, it's a new coding rule that could easily trip people up in the\\n>> future.\\n>\\n> It is valid, and probably most important. But if we introduce own mechanism,\\n> we will play with process latch too (although we can use LWlocks)\\n\\nWith the design I proposed, there is zero need to touch the process\\nlatch, which is good, because I'm pretty sure that is going to be a\\nproblem. I don't think there is any need to use LWLocks here either.\\nWhen you get a request for data, you can just publish a DSM segment\\nwith the data and that's it. Why do you need anything more? You\\ncould set the requestor's latch if it's convenient; that wouldn't be a\\nproblem. But the process supplying the data can't end up in a\\ndifferent state than it was before supplying that data, or stuff WILL\\nbreak.\\n\\n>> Using a shm_mq is appropriate when the amount of data that needs to be\\n>> transmitted might be very large - too large to just allocate a buffer\\n>> for the whole thing - or when the amount of data can't be predicted\\n>> before memory is allocated. But there is obviously no rule that a\\n>> shm_mq should be used any time we have \\\"data exchange between\\n>> processes\\\"; we have lots of shared-memory based IPC already and have\\n>> for many years, and shm_mq is newer than the vast majority of that\\n>> code.\\n>\\n> I am little bit disappointed - I hoped so shm_mq can be used as generic\\n> interprocess mechanism - that will ensure all corner cases for work with\\n> shared memory. I understand to shm_mq is new, and nobody used it, but this\\n> risk is better than invent wheels again and again.\\n\\nshm_mq is useful, but if you insist on using a complicated tool when a\\nsimple one is plenty sufficient, you may not get the results you're\\nhoping for.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 17 Sep 2015 16:13:12 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-17 16:37 GMT+02:00 Pavel Stehule <pavel.stehule@gmail.com>:\\n\\n>\\n>\\n> 2015-09-17 16:06 GMT+02:00 Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de>:\\n>\\n>> On Thu, Sep 17, 2015 at 12:06 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n>> wrote:\\n>>\\n>>>\\n>>>> That won't work really well with something like I use to do when\\n>>>> testing this patch, namely:\\n>>>>\\n>>>> postgres=# select pid, array(select pg_cmdstatus(pid, 1, 10)) from\\n>>>> pg_stat_activity where pid<>pg_backend_pid() \\\\watch 1\\n>>>>\\n>>>> while also running pgbench with -C option (to create new connection for\\n>>>> every transaction). When a targeted backend exits before it can handle the\\n>>>> signal, the receiving process keeps waiting forever.\\n>>>>\\n>>>\\n>>> no - every timeout you have to check, if targeted backend is living\\n>>> still, if not you will do cancel. It is 100% safe.\\n>>>\\n>>\\n>> But then you need to make this internal timeout rather short, not 1s as\\n>> originally suggested.\\n>>\\n>\\n> can be - 1 sec is max, maybe 100ms is optimum.\\n>\\n>>\\n>> The statement_timeout in this case will stop the whole select, not just\\n>>>> individual function call. Unless you wrap it to set statement_timeout and\\n>>>> catch QUERY_CANCELED in plpgsql, but then you won't be able to ^C the whole\\n>>>> select. The ability to set a (short) timeout for the function itself\\n>>>> proves to be a really useful feature to me.\\n>>>>\\n>>>\\n>>> you cannot to handle QUERY_CANCELED in plpgsql.\\n>>>\\n>>\\n>> Well, you can but its not that useful of course:\\n>>\\n>\\n> hmm, some is wrong - I remember from some older plpgsql, so CANCEL message\\n> is not catchable. Maybe I have bad memory. I have to recheck it.\\n>\\n\\nit is ok. I didn't remeber well this behave. You cannot to catch CANCEL\\n(and today ASSERT) in OTHER handler. It can be handled if it is explicitly\\nmentioned.\\n\\nRegards\\n\\nPavel\\n\\n 2015-09-17 16:37 GMT+02:00 Pavel Stehule <pavel.stehule@gmail.com>:2015-09-17 16:06 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Thu, Sep 17, 2015 at 12:06 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:That won't work really well with something like I use to do when testing this patch, namely:postgres=# select pid, array(select pg_cmdstatus(pid, 1, 10)) from pg_stat_activity where pid<>pg_backend_pid() \\\\watch 1while also running pgbench with -C option (to create new connection for every transaction). When a targeted backend exits before it can handle the signal, the receiving process keeps waiting forever.no - every timeout you have to check, if targeted backend is living still, if not you will do cancel. It is 100% safe.But then you need to make this internal timeout rather short, not 1s as originally suggested.can be - 1 sec is max, maybe 100ms is optimum. The statement_timeout in this case will stop the whole select, not just individual function call. Unless you wrap it to set statement_timeout and catch QUERY_CANCELED in plpgsql, but then you won't be able to ^C the whole select. The ability to set a (short) timeout for the function itself proves to be a really useful feature to me.you cannot to handle QUERY_CANCELED in plpgsql.Well, you can but its not that useful of course:hmm, some is wrong - I remember from some older plpgsql, so CANCEL message is not catchable. Maybe I have bad memory. I have to recheck it.it is ok. I didn't remeber well this behave. You cannot to catch CANCEL (and today ASSERT) in OTHER handler. It can be handled if it is explicitly mentioned.RegardsPavel\",\n \"msg_date\": \"Fri, 18 Sep 2015 06:16:51 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-17 22:13 GMT+02:00 Robert Haas <robertmhaas@gmail.com>:\\n\\n> On Thu, Sep 17, 2015 at 11:16 AM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n> > Is there some risk if we take too much large DSM segment? And what is max\\n> > size of DSM segment? When we use shm_mq, we don't need to solve limits.\\n>\\n> I can't really think you are going to have a problem. How much data\\n> do you really intend to send back? Surely it's going to be <100kB.\\n> If you think it's not a problem to have a running query stop and send\\n> a gigabyte of data someplace anytime somebody asks, well, I don't\\n> think I agree.\\n>\\n>\\nI afraid so <100kB is too optimistic. I know so GoodData environment is a\\nexception - it uses query generator, but I found few plans >1MB . It is\\nunusual probably due long identifiers too - used 63bytes long hash - and\\nsome queries and models are strange. It does translation between analytic\\nmulti dimensional business oriented query language and SQL. Back to topic.\\nWith high probability we can calculate <10MB.\\n\\n\\n> >> Also, if there are any bugs in the way the shm_mq is being used,\\n> >> they're likely to be quite rare and hard to find, because the vast\\n> >> majority of messages will probably be short enough to be sent in a\\n> >> single chunk, so whatever bugs may exist when the processes play\\n> >> ping-ping are unlikely to occur in practice except in unusual cases\\n> >> where the message being returned is very long.\\n> >\\n> > This is true for any functionality based on shm_mq - parallel seq scan,\\n>\\n> Parallel sequential scan is likely to put a lot more data through a\\n> shm_mq than you would for this.\\n>\\n> >> Second, using a shm_mq manipulates the state of the process latch. I\\n> >> don't think you can make the assumption that it's safe to reset the\\n> >> process latch at any and every place where we check for interrupts.\\n> >> For example, suppose the process is already using a shm_mq and the\\n> >> CHECK_FOR_INTERRUPTS() call inside that code then discovers that\\n> >> somebody has activated this mechanism and you now go try to send and\\n> >> receive from a new shm_mq. But even if that and every other\\n> >> CHECK_FOR_INTERRUPTS() in the code can tolerate a process latch reset\\n> >> today, it's a new coding rule that could easily trip people up in the\\n> >> future.\\n> >\\n> > It is valid, and probably most important. But if we introduce own\\n> mechanism,\\n> > we will play with process latch too (although we can use LWlocks)\\n>\\n> With the design I proposed, there is zero need to touch the process\\n> latch, which is good, because I'm pretty sure that is going to be a\\n> problem. I don't think there is any need to use LWLocks here either.\\n> When you get a request for data, you can just publish a DSM segment\\n> with the data and that's it. Why do you need anything more? You\\n> could set the requestor's latch if it's convenient; that wouldn't be a\\n> problem. But the process supplying the data can't end up in a\\n> different state than it was before supplying that data, or stuff WILL\\n> break.\\n>\\n\\nsure - but the same behave have to have shm_mq - if not, then only one can\\nbe used for communication between process - that is little bit limiting.\\n\\n>\\n> >> Using a shm_mq is appropriate when the amount of data that needs to be\\n> >> transmitted might be very large - too large to just allocate a buffer\\n> >> for the whole thing - or when the amount of data can't be predicted\\n> >> before memory is allocated. But there is obviously no rule that a\\n> >> shm_mq should be used any time we have \\\"data exchange between\\n> >> processes\\\"; we have lots of shared-memory based IPC already and have\\n> >> for many years, and shm_mq is newer than the vast majority of that\\n> >> code.\\n> >\\n> > I am little bit disappointed - I hoped so shm_mq can be used as generic\\n> > interprocess mechanism - that will ensure all corner cases for work with\\n> > shared memory. I understand to shm_mq is new, and nobody used it, but\\n> this\\n> > risk is better than invent wheels again and again.\\n>\\n> shm_mq is useful, but if you insist on using a complicated tool when a\\n> simple one is plenty sufficient, you may not get the results you're\\n> hoping for.\\n>\\n> --\\n> Robert Haas\\n> EnterpriseDB: http://www.enterprisedb.com\\n> The Enterprise PostgreSQL Company\\n>\\n\\n2015-09-17 22:13 GMT+02:00 Robert Haas <robertmhaas@gmail.com>:On Thu, Sep 17, 2015 at 11:16 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:\\n> Is there some risk if we take too much large DSM segment? And what is max\\n> size of DSM segment? When we use shm_mq, we don't need to solve limits.\\n\\nI can't really think you are going to have a problem. How much data\\ndo you really intend to send back? Surely it's going to be <100kB.\\nIf you think it's not a problem to have a running query stop and send\\na gigabyte of data someplace anytime somebody asks, well, I don't\\nthink I agree.\\nI afraid so <100kB is too optimistic. I know so GoodData environment is a exception - it uses query generator, but I found few plans >1MB . It is unusual probably due long identifiers too - used 63bytes long hash - and some queries and models are strange. It does translation between analytic multi dimensional business oriented query language and SQL. Back to topic. With high probability we can calculate <10MB. \\n>> Also, if there are any bugs in the way the shm_mq is being used,\\n>> they're likely to be quite rare and hard to find, because the vast\\n>> majority of messages will probably be short enough to be sent in a\\n>> single chunk, so whatever bugs may exist when the processes play\\n>> ping-ping are unlikely to occur in practice except in unusual cases\\n>> where the message being returned is very long.\\n>\\n> This is true for any functionality based on shm_mq - parallel seq scan,\\n\\nParallel sequential scan is likely to put a lot more data through a\\nshm_mq than you would for this.\\n\\n>> Second, using a shm_mq manipulates the state of the process latch. I\\n>> don't think you can make the assumption that it's safe to reset the\\n>> process latch at any and every place where we check for interrupts.\\n>> For example, suppose the process is already using a shm_mq and the\\n>> CHECK_FOR_INTERRUPTS() call inside that code then discovers that\\n>> somebody has activated this mechanism and you now go try to send and\\n>> receive from a new shm_mq. But even if that and every other\\n>> CHECK_FOR_INTERRUPTS() in the code can tolerate a process latch reset\\n>> today, it's a new coding rule that could easily trip people up in the\\n>> future.\\n>\\n> It is valid, and probably most important. But if we introduce own mechanism,\\n> we will play with process latch too (although we can use LWlocks)\\n\\nWith the design I proposed, there is zero need to touch the process\\nlatch, which is good, because I'm pretty sure that is going to be a\\nproblem. I don't think there is any need to use LWLocks here either.\\nWhen you get a request for data, you can just publish a DSM segment\\nwith the data and that's it. Why do you need anything more? You\\ncould set the requestor's latch if it's convenient; that wouldn't be a\\nproblem. But the process supplying the data can't end up in a\\ndifferent state than it was before supplying that data, or stuff WILL\\nbreak.sure - but the same behave have to have shm_mq - if not, then only one can be used for communication between process - that is little bit limiting. \\n\\n>> Using a shm_mq is appropriate when the amount of data that needs to be\\n>> transmitted might be very large - too large to just allocate a buffer\\n>> for the whole thing - or when the amount of data can't be predicted\\n>> before memory is allocated. But there is obviously no rule that a\\n>> shm_mq should be used any time we have \\\"data exchange between\\n>> processes\\\"; we have lots of shared-memory based IPC already and have\\n>> for many years, and shm_mq is newer than the vast majority of that\\n>> code.\\n>\\n> I am little bit disappointed - I hoped so shm_mq can be used as generic\\n> interprocess mechanism - that will ensure all corner cases for work with\\n> shared memory. I understand to shm_mq is new, and nobody used it, but this\\n> risk is better than invent wheels again and again.\\n\\nshm_mq is useful, but if you insist on using a complicated tool when a\\nsimple one is plenty sufficient, you may not get the results you're\\nhoping for.\\n\\n--\\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\",\n \"msg_date\": \"Fri, 18 Sep 2015 06:34:14 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 17, 2015 at 10:13 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n\\n> On Thu, Sep 17, 2015 at 11:16 AM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n>\\n> >> Second, using a shm_mq manipulates the state of the process latch. I\\n> >> don't think you can make the assumption that it's safe to reset the\\n> >> process latch at any and every place where we check for interrupts.\\n> >> For example, suppose the process is already using a shm_mq and the\\n> >> CHECK_FOR_INTERRUPTS() call inside that code then discovers that\\n> >> somebody has activated this mechanism and you now go try to send and\\n> >> receive from a new shm_mq. But even if that and every other\\n> >> CHECK_FOR_INTERRUPTS() in the code can tolerate a process latch reset\\n> >> today, it's a new coding rule that could easily trip people up in the\\n> >> future.\\n> >\\n> > It is valid, and probably most important. But if we introduce own\\n> mechanism,\\n> > we will play with process latch too (although we can use LWlocks)\\n>\\n> With the design I proposed, there is zero need to touch the process\\n> latch, which is good, because I'm pretty sure that is going to be a\\n> problem. I don't think there is any need to use LWLocks here either.\\n> When you get a request for data, you can just publish a DSM segment\\n> with the data and that's it. Why do you need anything more? You\\n> could set the requestor's latch if it's convenient; that wouldn't be a\\n> problem. But the process supplying the data can't end up in a\\n> different state than it was before supplying that data, or stuff WILL\\n> break.\\n>\\n\\nThere is still the whole problem of where exactly the backend being queried\\nfor the status should publish that DSM segment and when to free it?\\n\\nIf it's a location shared between all backends, there should be locking\\naround it. Probably this is not a big problem, if you don't expect all the\\nbackends start querying each other rapidly. That is how it was implemented\\nin the first versions of this patch actually.\\n\\nIf we take the per-backend slot approach the locking seems unnecessary and\\nthere are principally two options:\\n\\n1) The backend puts the DSM handle in its own slot and notifies the\\nrequester to read it.\\n2) The backend puts the DSM handle in the slot of the requester (and\\nnotifies it).\\n\\nIf we go with the first option, the backend that has created the DSM will\\nnot know when it's OK to free it, so this has to be responsibility of the\\nrequester. If the latter exits before reading and freeing the DSM, we have\\na leak. Even bigger is the problem that the sender backend can no longer\\nsend responses to a number of concurrent requestors: if its slot is\\noccupied by a DSM handle, it can not send a reply to another backend until\\nthe slot is freed.\\n\\nWith the second option we have all the same problems with not knowing when\\nto free the DSM and potentially leaking it, but we can handle concurrent\\nrequests.\\n\\nThe current approach where the requester creates and frees the DSM doesn't\\nsuffer from these problems, so if we pre-allocate the segment just big\\nenough we can avoid the use of shm_mq. That will take another GUC for the\\nsegment size. Certainly no one expects a query plan to weigh a bloody\\nmegabyte, but this is what happens to Pavel apparently.\\n\\n--\\nAlex\\n\\nOn Thu, Sep 17, 2015 at 10:13 PM, Robert Haas <robertmhaas@gmail.com> wrote:On Thu, Sep 17, 2015 at 11:16 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:\\n>> Second, using a shm_mq manipulates the state of the process latch. I\\n>> don't think you can make the assumption that it's safe to reset the\\n>> process latch at any and every place where we check for interrupts.\\n>> For example, suppose the process is already using a shm_mq and the\\n>> CHECK_FOR_INTERRUPTS() call inside that code then discovers that\\n>> somebody has activated this mechanism and you now go try to send and\\n>> receive from a new shm_mq. But even if that and every other\\n>> CHECK_FOR_INTERRUPTS() in the code can tolerate a process latch reset\\n>> today, it's a new coding rule that could easily trip people up in the\\n>> future.\\n>\\n> It is valid, and probably most important. But if we introduce own mechanism,\\n> we will play with process latch too (although we can use LWlocks)\\n\\nWith the design I proposed, there is zero need to touch the process\\nlatch, which is good, because I'm pretty sure that is going to be a\\nproblem. I don't think there is any need to use LWLocks here either.\\nWhen you get a request for data, you can just publish a DSM segment\\nwith the data and that's it. Why do you need anything more? You\\ncould set the requestor's latch if it's convenient; that wouldn't be a\\nproblem. But the process supplying the data can't end up in a\\ndifferent state than it was before supplying that data, or stuff WILL\\nbreak.There is still the whole problem of where exactly the backend being queried for the status should publish that DSM segment and when to free it?If it's a location shared between all backends, there should be locking around it. Probably this is not a big problem, if you don't expect all the backends start querying each other rapidly. That is how it was implemented in the first versions of this patch actually.If we take the per-backend slot approach the locking seems unnecessary and there are principally two options:1) The backend puts the DSM handle in its own slot and notifies the requester to read it.2) The backend puts the DSM handle in the slot of the requester (and notifies it).If we go with the first option, the backend that has created the DSM will not know when it's OK to free it, so this has to be responsibility of the requester. If the latter exits before reading and freeing the DSM, we have a leak. Even bigger is the problem that the sender backend can no longer send responses to a number of concurrent requestors: if its slot is occupied by a DSM handle, it can not send a reply to another backend until the slot is freed.With the second option we have all the same problems with not knowing when to free the DSM and potentially leaking it, but we can handle concurrent requests.The current approach where the requester creates and frees the DSM doesn't suffer from these problems, so if we pre-allocate the segment just big enough we can avoid the use of shm_mq. That will take another GUC for the segment size. Certainly no one expects a query plan to weigh a bloody megabyte, but this is what happens to Pavel apparently.--Alex\",\n \"msg_date\": \"Fri, 18 Sep 2015 10:59:54 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-18 10:59 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Thu, Sep 17, 2015 at 10:13 PM, Robert Haas <robertmhaas@gmail.com>\\n> wrote:\\n>\\n>> On Thu, Sep 17, 2015 at 11:16 AM, Pavel Stehule <pavel.stehule@gmail.com>\\n>> wrote:\\n>>\\n>> >> Second, using a shm_mq manipulates the state of the process latch. I\\n>> >> don't think you can make the assumption that it's safe to reset the\\n>> >> process latch at any and every place where we check for interrupts.\\n>> >> For example, suppose the process is already using a shm_mq and the\\n>> >> CHECK_FOR_INTERRUPTS() call inside that code then discovers that\\n>> >> somebody has activated this mechanism and you now go try to send and\\n>> >> receive from a new shm_mq. But even if that and every other\\n>> >> CHECK_FOR_INTERRUPTS() in the code can tolerate a process latch reset\\n>> >> today, it's a new coding rule that could easily trip people up in the\\n>> >> future.\\n>> >\\n>> > It is valid, and probably most important. But if we introduce own\\n>> mechanism,\\n>> > we will play with process latch too (although we can use LWlocks)\\n>>\\n>> With the design I proposed, there is zero need to touch the process\\n>> latch, which is good, because I'm pretty sure that is going to be a\\n>> problem. I don't think there is any need to use LWLocks here either.\\n>> When you get a request for data, you can just publish a DSM segment\\n>> with the data and that's it. Why do you need anything more? You\\n>> could set the requestor's latch if it's convenient; that wouldn't be a\\n>> problem. But the process supplying the data can't end up in a\\n>> different state than it was before supplying that data, or stuff WILL\\n>> break.\\n>>\\n>\\n> There is still the whole problem of where exactly the backend being\\n> queried for the status should publish that DSM segment and when to free it?\\n>\\n> If it's a location shared between all backends, there should be locking\\n> around it. Probably this is not a big problem, if you don't expect all the\\n> backends start querying each other rapidly. That is how it was implemented\\n> in the first versions of this patch actually.\\n>\\n> If we take the per-backend slot approach the locking seems unnecessary and\\n> there are principally two options:\\n>\\n> 1) The backend puts the DSM handle in its own slot and notifies the\\n> requester to read it.\\n> 2) The backend puts the DSM handle in the slot of the requester (and\\n> notifies it).\\n>\\n> If we go with the first option, the backend that has created the DSM will\\n> not know when it's OK to free it, so this has to be responsibility of the\\n> requester. If the latter exits before reading and freeing the DSM, we have\\n> a leak. Even bigger is the problem that the sender backend can no longer\\n> send responses to a number of concurrent requestors: if its slot is\\n> occupied by a DSM handle, it can not send a reply to another backend until\\n> the slot is freed.\\n>\\n> With the second option we have all the same problems with not knowing when\\n> to free the DSM and potentially leaking it, but we can handle concurrent\\n> requests.\\n>\\n\\nIt should not be true - the data sender create DSM and fills it. Then set\\ncaller slot and send signal to caller. Caller can free DSM any time,\\nbecause data sender send newer touch it.\\n\\n\\n>\\n> The current approach where the requester creates and frees the DSM doesn't\\n> suffer from these problems, so if we pre-allocate the segment just big\\n> enough we can avoid the use of shm_mq. That will take another GUC for the\\n> segment size. Certainly no one expects a query plan to weigh a bloody\\n> megabyte, but this is what happens to Pavel apparently.\\n>\\n\\nIt is plan C - last variant from my view. Any other GUC :(\\n\\nPavel\\n\\n\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n2015-09-18 10:59 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Thu, Sep 17, 2015 at 10:13 PM, Robert Haas <robertmhaas@gmail.com> wrote:On Thu, Sep 17, 2015 at 11:16 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:\\n>> Second, using a shm_mq manipulates the state of the process latch. I\\n>> don't think you can make the assumption that it's safe to reset the\\n>> process latch at any and every place where we check for interrupts.\\n>> For example, suppose the process is already using a shm_mq and the\\n>> CHECK_FOR_INTERRUPTS() call inside that code then discovers that\\n>> somebody has activated this mechanism and you now go try to send and\\n>> receive from a new shm_mq. But even if that and every other\\n>> CHECK_FOR_INTERRUPTS() in the code can tolerate a process latch reset\\n>> today, it's a new coding rule that could easily trip people up in the\\n>> future.\\n>\\n> It is valid, and probably most important. But if we introduce own mechanism,\\n> we will play with process latch too (although we can use LWlocks)\\n\\nWith the design I proposed, there is zero need to touch the process\\nlatch, which is good, because I'm pretty sure that is going to be a\\nproblem. I don't think there is any need to use LWLocks here either.\\nWhen you get a request for data, you can just publish a DSM segment\\nwith the data and that's it. Why do you need anything more? You\\ncould set the requestor's latch if it's convenient; that wouldn't be a\\nproblem. But the process supplying the data can't end up in a\\ndifferent state than it was before supplying that data, or stuff WILL\\nbreak.There is still the whole problem of where exactly the backend being queried for the status should publish that DSM segment and when to free it?If it's a location shared between all backends, there should be locking around it. Probably this is not a big problem, if you don't expect all the backends start querying each other rapidly. That is how it was implemented in the first versions of this patch actually.If we take the per-backend slot approach the locking seems unnecessary and there are principally two options:1) The backend puts the DSM handle in its own slot and notifies the requester to read it.2) The backend puts the DSM handle in the slot of the requester (and notifies it).If we go with the first option, the backend that has created the DSM will not know when it's OK to free it, so this has to be responsibility of the requester. If the latter exits before reading and freeing the DSM, we have a leak. Even bigger is the problem that the sender backend can no longer send responses to a number of concurrent requestors: if its slot is occupied by a DSM handle, it can not send a reply to another backend until the slot is freed.With the second option we have all the same problems with not knowing when to free the DSM and potentially leaking it, but we can handle concurrent requests.It should not be true - the data sender create DSM and fills it. Then set caller slot and send signal to caller. Caller can free DSM any time, because data sender send newer touch it. The current approach where the requester creates and frees the DSM doesn't suffer from these problems, so if we pre-allocate the segment just big enough we can avoid the use of shm_mq. That will take another GUC for the segment size. Certainly no one expects a query plan to weigh a bloody megabyte, but this is what happens to Pavel apparently.It is plan C - last variant from my view. Any other GUC :(Pavel --Alex\",\n \"msg_date\": \"Fri, 18 Sep 2015 11:25:24 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 18, 2015 at 11:25 AM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n\\n> 2015-09-18 10:59 GMT+02:00 Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de>:\\n>\\n>>\\n>> If we take the per-backend slot approach the locking seems unnecessary\\n>> and there are principally two options:\\n>>\\n>> 1) The backend puts the DSM handle in its own slot and notifies the\\n>> requester to read it.\\n>> 2) The backend puts the DSM handle in the slot of the requester (and\\n>> notifies it).\\n>>\\n>> If we go with the first option, the backend that has created the DSM will\\n>> not know when it's OK to free it, so this has to be responsibility of the\\n>> requester. If the latter exits before reading and freeing the DSM, we have\\n>> a leak. Even bigger is the problem that the sender backend can no longer\\n>> send responses to a number of concurrent requestors: if its slot is\\n>> occupied by a DSM handle, it can not send a reply to another backend until\\n>> the slot is freed.\\n>>\\n>> With the second option we have all the same problems with not knowing\\n>> when to free the DSM and potentially leaking it, but we can handle\\n>> concurrent requests.\\n>>\\n>\\n> It should not be true - the data sender create DSM and fills it. Then set\\n> caller slot and send signal to caller. Caller can free DSM any time,\\n> because data sender send newer touch it.\\n>\\n\\nBut the requester can timeout on waiting for reply and exit before it sees\\nthe reply DSM. Actually, I now don't even think a backend can free the DSM\\nit has not created. First it will need to attach it, effectively\\nincreasing the refcount, and upon detach it will only decrease the\\nrefcount, but not actually release the segment...\\n\\nSo this has to be the responsibility of the reply sending backend in the\\nend: to create and release the DSM *at some point*.\\n\\n--\\nAlex\\n\\nOn Fri, Sep 18, 2015 at 11:25 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-18 10:59 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:If we take the per-backend slot approach the locking seems unnecessary and there are principally two options:1) The backend puts the DSM handle in its own slot and notifies the requester to read it.2) The backend puts the DSM handle in the slot of the requester (and notifies it).If we go with the first option, the backend that has created the DSM will not know when it's OK to free it, so this has to be responsibility of the requester. If the latter exits before reading and freeing the DSM, we have a leak. Even bigger is the problem that the sender backend can no longer send responses to a number of concurrent requestors: if its slot is occupied by a DSM handle, it can not send a reply to another backend until the slot is freed.With the second option we have all the same problems with not knowing when to free the DSM and potentially leaking it, but we can handle concurrent requests.It should not be true - the data sender create DSM and fills it. Then set caller slot and send signal to caller. Caller can free DSM any time, because data sender send newer touch it.But the requester can timeout on waiting for reply and exit before it sees the reply DSM. Actually, I now don't even think a backend can free the DSM it has not created. First it will need to attach it, effectively increasing the refcount, and upon detach it will only decrease the refcount, but not actually release the segment...So this has to be the responsibility of the reply sending backend in the end: to create and release the DSM *at some point*.--Alex\",\n \"msg_date\": \"Fri, 18 Sep 2015 12:05:21 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-18 12:05 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Fri, Sep 18, 2015 at 11:25 AM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n>\\n>> 2015-09-18 10:59 GMT+02:00 Shulgin, Oleksandr <\\n>> oleksandr.shulgin@zalando.de>:\\n>>\\n>>>\\n>>> If we take the per-backend slot approach the locking seems unnecessary\\n>>> and there are principally two options:\\n>>>\\n>>> 1) The backend puts the DSM handle in its own slot and notifies the\\n>>> requester to read it.\\n>>> 2) The backend puts the DSM handle in the slot of the requester (and\\n>>> notifies it).\\n>>>\\n>>> If we go with the first option, the backend that has created the DSM\\n>>> will not know when it's OK to free it, so this has to be responsibility of\\n>>> the requester. If the latter exits before reading and freeing the DSM, we\\n>>> have a leak. Even bigger is the problem that the sender backend can no\\n>>> longer send responses to a number of concurrent requestors: if its slot is\\n>>> occupied by a DSM handle, it can not send a reply to another backend until\\n>>> the slot is freed.\\n>>>\\n>>> With the second option we have all the same problems with not knowing\\n>>> when to free the DSM and potentially leaking it, but we can handle\\n>>> concurrent requests.\\n>>>\\n>>\\n>> It should not be true - the data sender create DSM and fills it. Then set\\n>> caller slot and send signal to caller. Caller can free DSM any time,\\n>> because data sender send newer touch it.\\n>>\\n>\\n> But the requester can timeout on waiting for reply and exit before it sees\\n> the reply DSM. Actually, I now don't even think a backend can free the DSM\\n> it has not created. First it will need to attach it, effectively\\n> increasing the refcount, and upon detach it will only decrease the\\n> refcount, but not actually release the segment...\\n>\\n\\n\\nI am afraid so it has not simple and nice solution - when data sender will\\nwait for to moment when data are received, then we have same complexity\\nlike we use shm_mq.\\n\\nIsn't better to introduce new background worker with responsibility to\\nclean orphaned DSM?\\n\\nRegards\\n\\nPavel\\n\\n\\n>\\n> So this has to be the responsibility of the reply sending backend in the\\n> end: to create and release the DSM *at some point*.\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n2015-09-18 12:05 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Fri, Sep 18, 2015 at 11:25 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-18 10:59 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:If we take the per-backend slot approach the locking seems unnecessary and there are principally two options:1) The backend puts the DSM handle in its own slot and notifies the requester to read it.2) The backend puts the DSM handle in the slot of the requester (and notifies it).If we go with the first option, the backend that has created the DSM will not know when it's OK to free it, so this has to be responsibility of the requester. If the latter exits before reading and freeing the DSM, we have a leak. Even bigger is the problem that the sender backend can no longer send responses to a number of concurrent requestors: if its slot is occupied by a DSM handle, it can not send a reply to another backend until the slot is freed.With the second option we have all the same problems with not knowing when to free the DSM and potentially leaking it, but we can handle concurrent requests.It should not be true - the data sender create DSM and fills it. Then set caller slot and send signal to caller. Caller can free DSM any time, because data sender send newer touch it.But the requester can timeout on waiting for reply and exit before it sees the reply DSM. Actually, I now don't even think a backend can free the DSM it has not created. First it will need to attach it, effectively increasing the refcount, and upon detach it will only decrease the refcount, but not actually release the segment...I am afraid so it has not simple and nice solution - when data sender will wait for to moment when data are received, then we have same complexity like we use shm_mq.Isn't better to introduce new background worker with responsibility to clean orphaned DSM?RegardsPavel So this has to be the responsibility of the reply sending backend in the end: to create and release the DSM *at some point*.--Alex\",\n \"msg_date\": \"Fri, 18 Sep 2015 12:59:40 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 18, 2015 at 12:59 PM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n\\n> 2015-09-18 12:05 GMT+02:00 Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de>:\\n>\\n>> On Fri, Sep 18, 2015 at 11:25 AM, Pavel Stehule <pavel.stehule@gmail.com>\\n>> wrote:\\n>>\\n>>>\\n>>> It should not be true - the data sender create DSM and fills it. Then\\n>>> set caller slot and send signal to caller. Caller can free DSM any time,\\n>>> because data sender send newer touch it.\\n>>>\\n>>\\n>> But the requester can timeout on waiting for reply and exit before it\\n>> sees the reply DSM. Actually, I now don't even think a backend can free\\n>> the DSM it has not created. First it will need to attach it, effectively\\n>> increasing the refcount, and upon detach it will only decrease the\\n>> refcount, but not actually release the segment...\\n>>\\n>\\n> I am afraid so it has not simple and nice solution - when data sender will\\n> wait for to moment when data are received, then we have same complexity\\n> like we use shm_mq.\\n>\\n> Isn't better to introduce new background worker with responsibility to\\n> clean orphaned DSM?\\n>\\n\\nI'm not thrilled by this idea.\\n\\nWe don't even need a worker to do that, as leaked segments are reported by\\nthe backend itself upon transaction commit (see\\nResourceOwnerReleaseInternal), e.g:\\n\\nWARNING: dynamic shared memory leak: segment 808539725 still referenced\\n\\nStill I believe relying on some magic cleanup mechanism and not caring\\nabout managing the shared memory properly is not the way to go.\\n\\n--\\nAlex\\n\\nOn Fri, Sep 18, 2015 at 12:59 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-18 12:05 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Fri, Sep 18, 2015 at 11:25 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:It should not be true - the data sender create DSM and fills it. Then set caller slot and send signal to caller. Caller can free DSM any time, because data sender send newer touch it.But the requester can timeout on waiting for reply and exit before it sees the reply DSM. Actually, I now don't even think a backend can free the DSM it has not created. First it will need to attach it, effectively increasing the refcount, and upon detach it will only decrease the refcount, but not actually release the segment...I am afraid so it has not simple and nice solution - when data sender will wait for to moment when data are received, then we have same complexity like we use shm_mq.Isn't better to introduce new background worker with responsibility to clean orphaned DSM?I'm not thrilled by this idea.We don't even need a worker to do that, as leaked segments are reported by the backend itself upon transaction commit (see ResourceOwnerReleaseInternal), e.g:WARNING: dynamic shared memory leak: segment 808539725 still referencedStill I believe relying on some magic cleanup mechanism and not caring about managing the shared memory properly is not the way to go.--Alex\",\n \"msg_date\": \"Fri, 18 Sep 2015 13:22:16 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-18 13:22 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Fri, Sep 18, 2015 at 12:59 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n>\\n>> 2015-09-18 12:05 GMT+02:00 Shulgin, Oleksandr <\\n>> oleksandr.shulgin@zalando.de>:\\n>>\\n>>> On Fri, Sep 18, 2015 at 11:25 AM, Pavel Stehule <pavel.stehule@gmail.com\\n>>> > wrote:\\n>>>\\n>>>>\\n>>>> It should not be true - the data sender create DSM and fills it. Then\\n>>>> set caller slot and send signal to caller. Caller can free DSM any time,\\n>>>> because data sender send newer touch it.\\n>>>>\\n>>>\\n>>> But the requester can timeout on waiting for reply and exit before it\\n>>> sees the reply DSM. Actually, I now don't even think a backend can free\\n>>> the DSM it has not created. First it will need to attach it, effectively\\n>>> increasing the refcount, and upon detach it will only decrease the\\n>>> refcount, but not actually release the segment...\\n>>>\\n>>\\n>> I am afraid so it has not simple and nice solution - when data sender\\n>> will wait for to moment when data are received, then we have same\\n>> complexity like we use shm_mq.\\n>>\\n>> Isn't better to introduce new background worker with responsibility to\\n>> clean orphaned DSM?\\n>>\\n>\\n> I'm not thrilled by this idea.\\n>\\n> We don't even need a worker to do that, as leaked segments are reported by\\n> the backend itself upon transaction commit (see\\n> ResourceOwnerReleaseInternal), e.g:\\n>\\n> WARNING: dynamic shared memory leak: segment 808539725 still referenced\\n>\\n> Still I believe relying on some magic cleanup mechanism and not caring\\n> about managing the shared memory properly is not the way to go.\\n>\\n\\nIt was one my idea too, to check shared memory on exit. The disadvantage\\nis clean - some times you can wait too long - although the very practical\\nlimit for session is about 2h.\\n\\n\\n\\n\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n2015-09-18 13:22 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Fri, Sep 18, 2015 at 12:59 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-18 12:05 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Fri, Sep 18, 2015 at 11:25 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:It should not be true - the data sender create DSM and fills it. Then set caller slot and send signal to caller. Caller can free DSM any time, because data sender send newer touch it.But the requester can timeout on waiting for reply and exit before it sees the reply DSM. Actually, I now don't even think a backend can free the DSM it has not created. First it will need to attach it, effectively increasing the refcount, and upon detach it will only decrease the refcount, but not actually release the segment...I am afraid so it has not simple and nice solution - when data sender will wait for to moment when data are received, then we have same complexity like we use shm_mq.Isn't better to introduce new background worker with responsibility to clean orphaned DSM?I'm not thrilled by this idea.We don't even need a worker to do that, as leaked segments are reported by the backend itself upon transaction commit (see ResourceOwnerReleaseInternal), e.g:WARNING: dynamic shared memory leak: segment 808539725 still referencedStill I believe relying on some magic cleanup mechanism and not caring about managing the shared memory properly is not the way to go.It was one my idea too, to check shared memory on exit. The disadvantage is clean - some times you can wait too long - although the very practical limit for session is about 2h. --Alex\",\n \"msg_date\": \"Fri, 18 Sep 2015 13:34:05 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 17, 2015 at 12:47 PM, Shulgin, Oleksandr\\n<oleksandr.shulgin@zalando.de> wrote:\\n> But if we make the sender backend create the DSM with the response payload,\\n> it suddenly becomes really unclear at which point and who should make the\\n> final detach of that DSM. We're getting back to the problem of\\n> synchronization between these processes all over again.\\n\\nYes, some thought is needed here. There's not really a problem if\\nsomebody asks for information just once: you could just have the\\npublishing process keep it attached until process exit, and nothing\\nbad would happen. The real problem comes when multiple people ask for\\ninformation in quick succession: if you detach the old segment too\\nquickly after publishing it, the guy who requested that data might not\\nhave attached it yet, and then when he gets around to looking at it,\\nit won't be there.\\n\\nThis seems like a pretty solvable problem, though. For example, when\\nsomebody asks for information, they store in the main shared segment a\\npointer to their PGPROC and then they signal the target process, which\\nresponds by publishing a dsm_segment_id. When the requesting process\\nhas accessed it, or when it errors out or exits, it clears the PGPROC\\nand the dsm_segment_id. The publisher avoids unmapping it until that\\nhappens.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 18 Sep 2015 07:59:55 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 18, 2015 at 6:59 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:\\n> I am afraid so it has not simple and nice solution - when data sender will\\n> wait for to moment when data are received, then we have same complexity like\\n> we use shm_mq.\\n>\\n> Isn't better to introduce new background worker with responsibility to clean\\n> orphaned DSM?\\n\\nThat won't work, or at least not easily. On Windows, the DSM is\\ncleaned up by the operating system as soon as nobody has it mapped.\\n\\nFrankly, I think you guys are making this out to be way more\\ncomplicated than it really is. Basically, I think the process being\\nqueried should publish a DSM via a slot it owns. The recipient is\\nresponsible for reading it and then notifying the sender. If a second\\nprocess requests data before the first process reads its data, the\\nsecond process can either (1) become an additional reader of the\\nalready-published data or (2) wait for the first process to finish,\\nand then send its own inquiry.\\n\\nThere are some problems to solve here, but they hardly seem impossible.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 18 Sep 2015 13:04:50 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 18, 2015 at 7:04 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n\\n>\\n> Frankly, I think you guys are making this out to be way more\\n> complicated than it really is. Basically, I think the process being\\n> queried should publish a DSM via a slot it owns. The recipient is\\n> responsible for reading it and then notifying the sender. If a second\\n> process requests data before the first process reads its data, the\\n> second process can either (1) become an additional reader of the\\n> already-published data or (2) wait for the first process to finish,\\n> and then send its own inquiry.\\n>\\n> There are some problems to solve here, but they hardly seem impossible.\\n\\n\\nThank you Robert, for your invaluable input on this patch!\\n\\nI now believe that use of ProcessInterrupts() in the recently proposed\\ndesign as well as manipulation of proc latch due to use of shared memory\\nqueue are major blockers.\\n\\nIn order to simplify things up, I've taken a step back and looked again at\\nthe auto_explain contrib module. I now propose the most simple thing\\npossible in my opinion: a new GUC option for auto_explain. It will make\\nevery backend, in which the module is loaded via *_preload_libraries\\nmechanism or using CREATE EXTENSION/LOAD commands, to actively publish the\\nplans of queries in dynamic shared memory as long as\\nauto_explain.publish_plans is turned on.\\n\\nThe greatest part for me, is that this approach doesn't require handling of\\nsignals and is isolated in an external module, so it can be readily used\\nwith the current server versions, no need to wait for >= 9.6.\\n\\nSome implementation details:\\n\\nFor every backend that might be running (MaxBackends) we reserve a\\ndsm_handle slot in the addins shared memory. When the new option is turned\\non, the ExecutorRun hook will produce a plan in whatever format is\\nspecified by the auto_explain.log_format, allocate a DSM segment, copy the\\nplan into the segment and finally store the DSM handle into its own slot.\\nNo locking is required around this because every backend writes to its slot\\nexclusively, no other backend can be writing into it concurrently. In the\\nExecutorFinish hook we invalidate the backend's slot by setting the handle\\nto 0 and deallocate the DSM segment.\\n\\nReading of the plan is performed by a newly added function\\npg_explain_backend(PID). Since it can determine the target process'\\nbackendId, it simply reads the DSM handle from that backend's slot and\\ntries to attach it (there's not much point in checking the handle for being\\nnon-0, because the other backend could release the segment the moment after\\nwe've checked it, so we rely on dsm_attach returning non-NULL). If\\nattached successfully, we parse the contents and detach. At this point the\\nbackend to detach the last is actually releasing the segment, due to\\nreference counting.\\n\\nHandling of the nested statements plans is an open question. It can be\\nreally useful when the top-level plan is simply displaying a \\\"SELECT\\nmy_stored_procedure()\\\" and all the interesting stuff is happening behind\\nthe scenes, but I didn't start to think about how this could be implemented\\nyet.\\n\\nPavel was really interested in retrieving the complete query text/plans\\nwhich could be over a megabyte in his case (and pg_stat_activity.query is\\ncapped by 10240 bytes I believe). This is now possible with the patch, but\\nsome others might still want to put a threshold on the allocation,\\nespecially given this is shared memory. I can envision another GUC, but in\\nour experience the extremely long queries (and plans) are most of the time\\ndue to use of VALUES() or IN() clauses with a huge list of literals.\\n\\nI think we could fold the VALUES/IN into \\\"?\\\" if the query/plan text exceeds\\nthe specified threshold, or unconditionally (yes, pg_stat_statements, I'm\\nlooking at you). This should help in the cases when the most interesting\\npart is in the plan nodes near the end, but there's such a huge list of\\nliterals before it.\\n\\nFuture plans:\\n\\nI believe this approach can be extended to enable instrumentation once\\nagain. The backend executing the query could update the published plan\\nevery once in a while (for example, every N ms or 1% of rows processed in a\\nnode), and any other process interested in this data, can simply read it\\nwithout the need for signals and complex and fragile communication. This\\nobviously requires a core patch.\\n\\nSome problems:\\n\\nThere is a potential problem with the limited total number of DSM segments:\\nit is reserved in a way to only allow 2 per backend (on average) and 64\\nadditional per server, so if you run with the new option enabled at all\\ntimes, you're down to only 1 additional DSM per backend (again, on\\naverage). Not sure how critical this can be, but no one is forced to run\\nwith this option enabled for all backends.\\n\\nIf you don't want to run it enabled at all times, then enabling the GUC\\nper-backend can be problematic. It's still possible to update the conf\\nfile and send SIGHUP to a single backend, but it's harder to accomplish\\nover psql, for example. I think here we might still have some luck with\\nthe signals: use another array of per-backend slots with flags, set the\\ntarget backend's flag and send it SIGUSR1. The backend wakes on the signal\\nand examines its slot, then toggles the GUC if needed. Sounds pretty safe,\\neh?\\n\\nNo documentation changes yet, waiting for your comments. :-)\\n\\nHappy hacking!\\n--\\nAlex\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Fri, 25 Sep 2015 19:13:13 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-25 19:13 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n>\\n>\\n> Some problems:\\n>\\n> There is a potential problem with the limited total number of DSM\\n> segments: it is reserved in a way to only allow 2 per backend (on average)\\n> and 64 additional per server, so if you run with the new option enabled at\\n> all times, you're down to only 1 additional DSM per backend (again, on\\n> average). Not sure how critical this can be, but no one is forced to run\\n> with this option enabled for all backends.\\n>\\n> If you don't want to run it enabled at all times, then enabling the GUC\\n> per-backend can be problematic. It's still possible to update the conf\\n> file and send SIGHUP to a single backend, but it's harder to accomplish\\n> over psql, for example. I think here we might still have some luck with\\n> the signals: use another array of per-backend slots with flags, set the\\n> target backend's flag and send it SIGUSR1. The backend wakes on the signal\\n> and examines its slot, then toggles the GUC if needed. Sounds pretty safe,\\n> eh?\\n>\\n> No documentation changes yet, waiting for your comments. :-)\\n>\\n\\nthe preparing of content before execution is interesting idea, that can be\\nused more. The almost queries and plans are not too big, so when the size\\nof content is not too big - less than 1MB, then can be used one DSM for all\\nbackends. When size of content is bigger than limit, then DSM will be\\nallocated specially for this content. The pointer to DSM and offset can be\\nstored in requested process slot. The reading and writing to requested slot\\nshould be protected by spinlock, but it should block only two related\\nprocesses for short time (copy memory). Other possibility is showing the\\nsize of content in requested process slot. Then the requester can\\npreallocate enough size of shared memory. But this doesn't solve a issues\\nrelated to waiting requester for content. So first variant is pretty\\nsimple, and should be preferred. The disadvantage is clear - it can enforce\\nmaybe significant slowdown of fast queries.\\n\\nRegards\\n\\nPavel\\n\\n\\n\\n\\n\\n> Happy hacking!\\n> --\\n> Alex\\n>\\n>\\n\\n2015-09-25 19:13 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:Some problems:There is a potential problem with the limited total number of DSM segments: it is reserved in a way to only allow 2 per backend (on average) and 64 additional per server, so if you run with the new option enabled at all times, you're down to only 1 additional DSM per backend (again, on average). Not sure how critical this can be, but no one is forced to run with this option enabled for all backends.If you don't want to run it enabled at all times, then enabling the GUC per-backend can be problematic. It's still possible to update the conf file and send SIGHUP to a single backend, but it's harder to accomplish over psql, for example. I think here we might still have some luck with the signals: use another array of per-backend slots with flags, set the target backend's flag and send it SIGUSR1. The backend wakes on the signal and examines its slot, then toggles the GUC if needed. Sounds pretty safe, eh?No documentation changes yet, waiting for your comments. :-)the preparing of content before execution is interesting idea, that can be used more. The almost queries and plans are not too big, so when the size of content is not too big - less than 1MB, then can be used one DSM for all backends. When size of content is bigger than limit, then DSM will be allocated specially for this content. The pointer to DSM and offset can be stored in requested process slot. The reading and writing to requested slot should be protected by spinlock, but it should block only two related processes for short time (copy memory). Other possibility is showing the size of content in requested process slot. Then the requester can preallocate enough size of shared memory. But this doesn't solve a issues related to waiting requester for content. So first variant is pretty simple, and should be preferred. The disadvantage is clear - it can enforce maybe significant slowdown of fast queries.RegardsPavelHappy hacking!--Alex\",\n \"msg_date\": \"Sun, 27 Sep 2015 08:05:18 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Sun, Sep 27, 2015 at 8:05 AM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n\\nthe preparing of content before execution is interesting idea, that can be\\n> used more. The almost queries and plans are not too big, so when the size\\n> of content is not too big - less than 1MB, then can be used one DSM for all\\n> backends.\\n>\\n\\n\\n> When size of content is bigger than limit, then DSM will be allocated\\n> specially for this content. The pointer to DSM and offset can be stored in\\n> requested process slot. The reading and writing to requested slot should be\\n> protected by spinlock, but it should block only two related processes for\\n> short time (copy memory).\\n>\\n\\nSorry, I don't think this will fly.\\n\\nThe whole idea is that a backend publishes the plan of a query just before\\nrunning it and it doesn't care which other backend(s) might be reading it,\\nhow many times and in which order. The only required locking (implicit) is\\ncontained in the code for dsm_attach/detach().\\n\\n\\n> Other possibility is showing the size of content in requested process\\n> slot. Then the requester can preallocate enough size of shared memory. But\\n> this doesn't solve a issues related to waiting requester for content. So\\n> first variant is pretty simple, and should be preferred. The disadvantage\\n> is clear - it can enforce maybe significant slowdown of fast queries.\\n>\\n\\nBoth of these approaches have just too many synchronization problems, IMO.\\n\\n--\\nAlex\\n\\nOn Sun, Sep 27, 2015 at 8:05 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:the preparing of content before execution is interesting idea, that can be used more. The almost queries and plans are not too big, so when the size of content is not too big - less than 1MB, then can be used one DSM for all backends. When size of content is bigger than limit, then DSM will be allocated specially for this content. The pointer to DSM and offset can be stored in requested process slot. The reading and writing to requested slot should be protected by spinlock, but it should block only two related processes for short time (copy memory).Sorry, I don't think this will fly.The whole idea is that a backend publishes the plan of a query just before running it and it doesn't care which other backend(s) might be reading it, how many times and in which order. The only required locking (implicit) is contained in the code for dsm_attach/detach(). Other possibility is showing the size of content in requested process slot. Then the requester can preallocate enough size of shared memory. But this doesn't solve a issues related to waiting requester for content. So first variant is pretty simple, and should be preferred. The disadvantage is clear - it can enforce maybe significant slowdown of fast queries.Both of these approaches have just too many synchronization problems, IMO.--Alex\",\n \"msg_date\": \"Mon, 28 Sep 2015 12:01:13 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-28 12:01 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Sun, Sep 27, 2015 at 8:05 AM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n>\\n> the preparing of content before execution is interesting idea, that can be\\n>> used more. The almost queries and plans are not too big, so when the size\\n>> of content is not too big - less than 1MB, then can be used one DSM for all\\n>> backends.\\n>>\\n>\\n>\\n>> When size of content is bigger than limit, then DSM will be allocated\\n>> specially for this content. The pointer to DSM and offset can be stored in\\n>> requested process slot. The reading and writing to requested slot should be\\n>> protected by spinlock, but it should block only two related processes for\\n>> short time (copy memory).\\n>>\\n>\\n> Sorry, I don't think this will fly.\\n>\\n> The whole idea is that a backend publishes the plan of a query just before\\n> running it and it doesn't care which other backend(s) might be reading it,\\n> how many times and in which order. The only required locking (implicit) is\\n> contained in the code for dsm_attach/detach().\\n>\\n\\nI didn't propose too different solution. There is only one difference -\\nsharing DSM for smaller data. It is similar to using usual shared memory.\\n\\nRegards\\n\\nPavel\\n\\n>\\n>\\n>> Other possibility is showing the size of content in requested process\\n>> slot. Then the requester can preallocate enough size of shared memory. But\\n>> this doesn't solve a issues related to waiting requester for content. So\\n>> first variant is pretty simple, and should be preferred. The disadvantage\\n>> is clear - it can enforce maybe significant slowdown of fast queries.\\n>>\\n>\\n> Both of these approaches have just too many synchronization problems, IMO.\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n2015-09-28 12:01 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Sun, Sep 27, 2015 at 8:05 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:the preparing of content before execution is interesting idea, that can be used more. The almost queries and plans are not too big, so when the size of content is not too big - less than 1MB, then can be used one DSM for all backends. When size of content is bigger than limit, then DSM will be allocated specially for this content. The pointer to DSM and offset can be stored in requested process slot. The reading and writing to requested slot should be protected by spinlock, but it should block only two related processes for short time (copy memory).Sorry, I don't think this will fly.The whole idea is that a backend publishes the plan of a query just before running it and it doesn't care which other backend(s) might be reading it, how many times and in which order. The only required locking (implicit) is contained in the code for dsm_attach/detach().I didn't propose too different solution. There is only one difference - sharing DSM for smaller data. It is similar to using usual shared memory.RegardsPavel Other possibility is showing the size of content in requested process slot. Then the requester can preallocate enough size of shared memory. But this doesn't solve a issues related to waiting requester for content. So first variant is pretty simple, and should be preferred. The disadvantage is clear - it can enforce maybe significant slowdown of fast queries.Both of these approaches have just too many synchronization problems, IMO.--Alex\",\n \"msg_date\": \"Mon, 28 Sep 2015 12:05:11 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Mon, Sep 28, 2015 at 12:05 PM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n\\n>\\n> 2015-09-28 12:01 GMT+02:00 Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de>:\\n>\\n>> On Sun, Sep 27, 2015 at 8:05 AM, Pavel Stehule <pavel.stehule@gmail.com>\\n>> wrote:\\n>>\\n>> the preparing of content before execution is interesting idea, that can\\n>>> be used more. The almost queries and plans are not too big, so when the\\n>>> size of content is not too big - less than 1MB, then can be used one DSM\\n>>> for all backends.\\n>>>\\n>>\\n>>\\n>>> When size of content is bigger than limit, then DSM will be allocated\\n>>> specially for this content. The pointer to DSM and offset can be stored in\\n>>> requested process slot. The reading and writing to requested slot should be\\n>>> protected by spinlock, but it should block only two related processes for\\n>>> short time (copy memory).\\n>>>\\n>>\\n>> Sorry, I don't think this will fly.\\n>>\\n>> The whole idea is that a backend publishes the plan of a query just\\n>> before running it and it doesn't care which other backend(s) might be\\n>> reading it, how many times and in which order. The only required locking\\n>> (implicit) is contained in the code for dsm_attach/detach().\\n>>\\n>\\n> I didn't propose too different solution. There is only one difference -\\n> sharing DSM for smaller data. It is similar to using usual shared memory.\\n>\\n\\nDoes this mean implementing some sort of allocator on top of the shared\\nmemory segment? If so, how are you going to prevent fragmentation?\\n\\n--\\nAlex\\n\\nOn Mon, Sep 28, 2015 at 12:05 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-28 12:01 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Sun, Sep 27, 2015 at 8:05 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:the preparing of content before execution is interesting idea, that can be used more. The almost queries and plans are not too big, so when the size of content is not too big - less than 1MB, then can be used one DSM for all backends. When size of content is bigger than limit, then DSM will be allocated specially for this content. The pointer to DSM and offset can be stored in requested process slot. The reading and writing to requested slot should be protected by spinlock, but it should block only two related processes for short time (copy memory).Sorry, I don't think this will fly.The whole idea is that a backend publishes the plan of a query just before running it and it doesn't care which other backend(s) might be reading it, how many times and in which order. The only required locking (implicit) is contained in the code for dsm_attach/detach().I didn't propose too different solution. There is only one difference - sharing DSM for smaller data. It is similar to using usual shared memory.Does this mean implementing some sort of allocator on top of the shared memory segment? If so, how are you going to prevent fragmentation?--Alex\",\n \"msg_date\": \"Mon, 28 Sep 2015 12:37:42 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 25, 2015 at 7:13 PM, Shulgin, Oleksandr <\\noleksandr.shulgin@zalando.de> wrote:\\n\\n>\\n> Some implementation details:\\n>\\n> For every backend that might be running (MaxBackends) we reserve a\\n> dsm_handle slot in the addins shared memory. When the new option is turned\\n> on, the ExecutorRun hook will produce a plan in whatever format is\\n> specified by the auto_explain.log_format, allocate a DSM segment, copy the\\n> plan into the segment and finally store the DSM handle into its own slot.\\n> No locking is required around this because every backend writes to its slot\\n> exclusively, no other backend can be writing into it concurrently. In the\\n> ExecutorFinish hook we invalidate the backend's slot by setting the handle\\n> to 0 and deallocate the DSM segment.\\n>\\n\\nAnd this patch adds back the use of table of contents on the DSM.\\nBenefits: magic number validation; communication of the actual plan size.\\n\\n--\\nAlex\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 28 Sep 2015 16:24:33 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-28 12:37 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Mon, Sep 28, 2015 at 12:05 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n>\\n>>\\n>> 2015-09-28 12:01 GMT+02:00 Shulgin, Oleksandr <\\n>> oleksandr.shulgin@zalando.de>:\\n>>\\n>>> On Sun, Sep 27, 2015 at 8:05 AM, Pavel Stehule <pavel.stehule@gmail.com>\\n>>> wrote:\\n>>>\\n>>> the preparing of content before execution is interesting idea, that can\\n>>>> be used more. The almost queries and plans are not too big, so when the\\n>>>> size of content is not too big - less than 1MB, then can be used one DSM\\n>>>> for all backends.\\n>>>>\\n>>>\\n>>>\\n>>>> When size of content is bigger than limit, then DSM will be allocated\\n>>>> specially for this content. The pointer to DSM and offset can be stored in\\n>>>> requested process slot. The reading and writing to requested slot should be\\n>>>> protected by spinlock, but it should block only two related processes for\\n>>>> short time (copy memory).\\n>>>>\\n>>>\\n>>> Sorry, I don't think this will fly.\\n>>>\\n>>> The whole idea is that a backend publishes the plan of a query just\\n>>> before running it and it doesn't care which other backend(s) might be\\n>>> reading it, how many times and in which order. The only required locking\\n>>> (implicit) is contained in the code for dsm_attach/detach().\\n>>>\\n>>\\n>> I didn't propose too different solution. There is only one difference -\\n>> sharing DSM for smaller data. It is similar to using usual shared memory.\\n>>\\n>\\n> Does this mean implementing some sort of allocator on top of the shared\\n> memory segment? If so, how are you going to prevent fragmentation?\\n>\\n\\nyes, simple memory allocator is necessary in this case. But it should be\\nreally simple - you can allocate only fixed size blocks - 10KB, 100KB and\\n1MB from separate buffers. So the fragmentation is not possible.\\n\\nRegards\\n\\nPavel\\n\\n\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n2015-09-28 12:37 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Mon, Sep 28, 2015 at 12:05 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-28 12:01 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Sun, Sep 27, 2015 at 8:05 AM, Pavel Stehule <pavel.stehule@gmail.com> wrote:the preparing of content before execution is interesting idea, that can be used more. The almost queries and plans are not too big, so when the size of content is not too big - less than 1MB, then can be used one DSM for all backends. When size of content is bigger than limit, then DSM will be allocated specially for this content. The pointer to DSM and offset can be stored in requested process slot. The reading and writing to requested slot should be protected by spinlock, but it should block only two related processes for short time (copy memory).Sorry, I don't think this will fly.The whole idea is that a backend publishes the plan of a query just before running it and it doesn't care which other backend(s) might be reading it, how many times and in which order. The only required locking (implicit) is contained in the code for dsm_attach/detach().I didn't propose too different solution. There is only one difference - sharing DSM for smaller data. It is similar to using usual shared memory.Does this mean implementing some sort of allocator on top of the shared memory segment? If so, how are you going to prevent fragmentation?yes, simple memory allocator is necessary in this case. But it should be really simple - you can allocate only fixed size blocks - 10KB, 100KB and 1MB from separate buffers. So the fragmentation is not possible.RegardsPavel --Alex\",\n \"msg_date\": \"Mon, 28 Sep 2015 19:09:54 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Mon, Sep 28, 2015 at 7:09 PM, Pavel Stehule <pavel.stehule@gmail.com>\\nwrote:\\n\\n>\\n> 2015-09-28 12:37 GMT+02:00 Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de>:\\n>\\n>>\\n>>> I didn't propose too different solution. There is only one difference -\\n>>> sharing DSM for smaller data. It is similar to using usual shared memory.\\n>>>\\n>>\\n>> Does this mean implementing some sort of allocator on top of the shared\\n>> memory segment? If so, how are you going to prevent fragmentation?\\n>>\\n>\\n> yes, simple memory allocator is necessary in this case. But it should be\\n> really simple - you can allocate only fixed size blocks - 10KB, 100KB and\\n> 1MB from separate buffers. So the fragmentation is not possible.\\n>\\n\\nMaybe we're talking about completely different ideas, but I don't see how\\nfixing the block helps to fight fragmentation, in particular. Can you\\nsketch a simple example? E.g. 400 backends share the common segment and\\nall of them want to publish a plan of ~1kb, for example. Now what?\\n\\n--\\nAlex\\n\\nOn Mon, Sep 28, 2015 at 7:09 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-28 12:37 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:I didn't propose too different solution. There is only one difference - sharing DSM for smaller data. It is similar to using usual shared memory.Does this mean implementing some sort of allocator on top of the shared memory segment? If so, how are you going to prevent fragmentation?yes, simple memory allocator is necessary in this case. But it should be really simple - you can allocate only fixed size blocks - 10KB, 100KB and 1MB from separate buffers. So the fragmentation is not possible.Maybe we're talking about completely different ideas, but I don't see how fixing the block helps to fight fragmentation, in particular. Can you sketch a simple example? E.g. 400 backends share the common segment and all of them want to publish a plan of ~1kb, for example. Now what?--Alex\",\n \"msg_date\": \"Mon, 28 Sep 2015 19:13:55 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-09-28 19:13 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>\\n:\\n\\n> On Mon, Sep 28, 2015 at 7:09 PM, Pavel Stehule <pavel.stehule@gmail.com>\\n> wrote:\\n>\\n>>\\n>> 2015-09-28 12:37 GMT+02:00 Shulgin, Oleksandr <\\n>> oleksandr.shulgin@zalando.de>:\\n>>\\n>>>\\n>>>> I didn't propose too different solution. There is only one difference -\\n>>>> sharing DSM for smaller data. It is similar to using usual shared memory.\\n>>>>\\n>>>\\n>>> Does this mean implementing some sort of allocator on top of the shared\\n>>> memory segment? If so, how are you going to prevent fragmentation?\\n>>>\\n>>\\n>> yes, simple memory allocator is necessary in this case. But it should be\\n>> really simple - you can allocate only fixed size blocks - 10KB, 100KB and\\n>> 1MB from separate buffers. So the fragmentation is not possible.\\n>>\\n>\\n> Maybe we're talking about completely different ideas, but I don't see how\\n> fixing the block helps to fight fragmentation, in particular. Can you\\n> sketch a simple example? E.g. 400 backends share the common segment and\\n> all of them want to publish a plan of ~1kb, for example. Now what?\\n>\\n\\n\\nProbably only few backends will be data requesters and few backends will be\\nrequested for data. The size of shared data will be typically less than\\n10KB, with few exceptions 100KB, and few exceptions 10MB. So for 400\\nbackends you need 400*10KB+100*100KB+20*1MB = 34MB. You can have three\\nindependent buffers for this sizes. If some process require 5KB then you\\nreturns 10KB (it is good enough) from first buffer. This simple mechanism\\ncan coverage 90% of usage. for other 10% you can create new DSM. Because\\nyou are working with fixed size blocks and you don't divide the size of\\nblock, then the fragmentation isn't possible. This model allow very fast\\nallocation, very fast deallocation.\\n\\nIt is not terribly effective, but 34MB is better than 400 DSM or than 400MB\\n(max size for any backend).\\n\\nOur super long queries are terribly long > 1MB, but we use a few clients\\n(less than 2x CPU cores)\\n\\nRegards\\n\\nPavel\\n\\n\\n>\\n> --\\n> Alex\\n>\\n>\\n\\n2015-09-28 19:13 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:On Mon, Sep 28, 2015 at 7:09 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:2015-09-28 12:37 GMT+02:00 Shulgin, Oleksandr <oleksandr.shulgin@zalando.de>:I didn't propose too different solution. There is only one difference - sharing DSM for smaller data. It is similar to using usual shared memory.Does this mean implementing some sort of allocator on top of the shared memory segment? If so, how are you going to prevent fragmentation?yes, simple memory allocator is necessary in this case. But it should be really simple - you can allocate only fixed size blocks - 10KB, 100KB and 1MB from separate buffers. So the fragmentation is not possible.Maybe we're talking about completely different ideas, but I don't see how fixing the block helps to fight fragmentation, in particular. Can you sketch a simple example? E.g. 400 backends share the common segment and all of them want to publish a plan of ~1kb, for example. Now what?Probably only few backends will be data requesters and few backends will be requested for data. The size of shared data will be typically less than 10KB, with few exceptions 100KB, and few exceptions 10MB. So for 400 backends you need 400*10KB+100*100KB+20*1MB = 34MB. You can have three independent buffers for this sizes. If some process require 5KB then you returns 10KB (it is good enough) from first buffer. This simple mechanism can coverage 90% of usage. for other 10% you can create new DSM. Because you are working with fixed size blocks and you don't divide the size of block, then the fragmentation isn't possible. This model allow very fast allocation, very fast deallocation. It is not terribly effective, but 34MB is better than 400 DSM or than 400MB (max size for any backend).Our super long queries are terribly long > 1MB, but we use a few clients (less than 2x CPU cores)RegardsPavel --Alex\",\n \"msg_date\": \"Mon, 28 Sep 2015 20:06:35 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On 9/18/15 5:05 AM, Shulgin, Oleksandr wrote:\\n>\\n> It should not be true - the data sender create DSM and fills it.\\n> Then set caller slot and send signal to caller. Caller can free DSM\\n> any time, because data sender send newer touch it.\\n>\\n>\\n> But the requester can timeout on waiting for reply and exit before it\\n> sees the reply DSM. Actually, I now don't even think a backend can free\\n> the DSM it has not created. First it will need to attach it,\\n> effectively increasing the refcount, and upon detach it will only\\n> decrease the refcount, but not actually release the segment...\\n>\\n> So this has to be the responsibility of the reply sending backend in the\\n> end: to create and release the DSM *at some point*.\\n\\nWhat's wrong with just releasing it at the end of the statement? When \\nthe statement is done there's no point to reading it asynchronously anymore.\\n-- \\nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\\nExperts in Analytics, Data Architecture and PostgreSQL\\nData in Trouble? Get it in Treble! http://BlueTreble.com\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 28 Sep 2015 17:28:12 -0500\",\n \"msg_from\": \"Jim Nasby <Jim.Nasby@BlueTreble.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and\\n signals\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 29, 2015 at 12:28 AM, Jim Nasby <Jim.Nasby@bluetreble.com>\\nwrote:\\n\\n> On 9/18/15 5:05 AM, Shulgin, Oleksandr wrote:\\n>\\n>>\\n>> So this has to be the responsibility of the reply sending backend in the\\n>> end: to create and release the DSM *at some point*.\\n>>\\n>\\n> What's wrong with just releasing it at the end of the statement? When the\\n> statement is done there's no point to reading it asynchronously anymore.\\n\\n\\nThat was only one of the problems in signals-based design, and it has other\\nmore significant problems. The current approach does exactly that:\\nallocate the segment before running the plan, release at the end of the\\nstatement.\\n\\n--\\nAlex\\n\\nOn Tue, Sep 29, 2015 at 12:28 AM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:On 9/18/15 5:05 AM, Shulgin, Oleksandr wrote:\\n\\nSo this has to be the responsibility of the reply sending backend in the\\nend: to create and release the DSM *at some point*.\\n\\n\\nWhat's wrong with just releasing it at the end of the statement? When the statement is done there's no point to reading it asynchronously anymore.That was only one of the problems in signals-based design, and it has other more significant problems. The current approach does exactly that: allocate the segment before running the plan, release at the end of the statement.--Alex\",\n \"msg_date\": \"Tue, 29 Sep 2015 12:52:11 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On 2015-09-25 19:13:13 +0200, Shulgin, Oleksandr wrote:\\n> the auto_explain contrib module. I now propose the most simple thing\\n> possible in my opinion: a new GUC option for auto_explain. It will make\\n> every backend, in which the module is loaded via *_preload_libraries\\n> mechanism or using CREATE EXTENSION/LOAD commands, to actively publish the\\n> plans of queries in dynamic shared memory as long as\\n> auto_explain.publish_plans is turned on.\\n\\nWait. You're proposing that every query does this unconditionally? For\\nevery single query? That sounds prohibitively expensive to me.\\n\\nGreetings,\\n\\nAndres Freund\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 29 Sep 2015 12:57:25 +0200\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and\\n signals\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 29, 2015 at 12:57 PM, Andres Freund <andres@anarazel.de> wrote:\\n\\n> On 2015-09-25 19:13:13 +0200, Shulgin, Oleksandr wrote:\\n> > the auto_explain contrib module. I now propose the most simple thing\\n> > possible in my opinion: a new GUC option for auto_explain. It will make\\n> > every backend, in which the module is loaded via *_preload_libraries\\n> > mechanism or using CREATE EXTENSION/LOAD commands, to actively publish\\n> the\\n> > plans of queries in dynamic shared memory as long as\\n> > auto_explain.publish_plans is turned on.\\n>\\n> Wait. You're proposing that every query does this unconditionally? For\\n> every single query? That sounds prohibitively expensive to me.\\n>\\n\\nOnly if the extension is loaded AND the option is turned on. Likely you\\ndon't want to do this for an OLTP database, but for other types of load it\\nmight make sense. Also, I think it should be possible to toggle this on a\\nper-process basis.\\n\\nFinally, we can put in a cost threshold, so the plans only get published if\\nthey have total_cost >= publish_plan_cost_threshod.\\n\\nAlso, do you mean expensive in terms of CPU or the dynamic shared memory?\\n\\n--\\nAlex\\n\\nOn Tue, Sep 29, 2015 at 12:57 PM, Andres Freund <andres@anarazel.de> wrote:On 2015-09-25 19:13:13 +0200, Shulgin, Oleksandr wrote:\\n> the auto_explain contrib module. I now propose the most simple thing\\n> possible in my opinion: a new GUC option for auto_explain. It will make\\n> every backend, in which the module is loaded via *_preload_libraries\\n> mechanism or using CREATE EXTENSION/LOAD commands, to actively publish the\\n> plans of queries in dynamic shared memory as long as\\n> auto_explain.publish_plans is turned on.\\n\\nWait. You're proposing that every query does this unconditionally? For\\nevery single query? That sounds prohibitively expensive to me.Only if the extension is loaded AND the option is turned on. Likely you don't want to do this for an OLTP database, but for other types of load it might make sense. Also, I think it should be possible to toggle this on a per-process basis.Finally, we can put in a cost threshold, so the plans only get published if they have total_cost >= publish_plan_cost_threshod.Also, do you mean expensive in terms of CPU or the dynamic shared memory?--Alex\",\n \"msg_date\": \"Tue, 29 Sep 2015 13:12:35 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On 25 September 2015 at 12:13, Shulgin, Oleksandr <\\noleksandr.shulgin@zalando.de> wrote:\\n\\n\\n> I now believe that use of ProcessInterrupts() in the recently proposed\\n> design as well as manipulation of proc latch due to use of shared memory\\n> queue are major blockers.\\n>\\n> In order to simplify things up, I've taken a step back and looked again at\\n> the auto_explain contrib module. I now propose the most simple thing\\n> possible in my opinion: a new GUC option for auto_explain. It will make\\n> every backend, in which the module is loaded via *_preload_libraries\\n> mechanism or using CREATE EXTENSION/LOAD commands, to actively publish the\\n> plans of queries in dynamic shared memory as long as\\n> auto_explain.publish_plans is turned on.\\n>\\n> The greatest part for me, is that this approach doesn't require handling\\n> of signals and is isolated in an external module, so it can be readily used\\n> with the current server versions, no need to wait for >= 9.6.\\n>\\n\\nThis is a major change of direction, so the thread title no longer applies\\nat all.\\n\\nThe requirement is to be able to see the output of EXPLAIN ANALYZE for a\\nrunning process. Ideally, we would dump the diagnostic output for any\\nprocess that runs longer than a specific timeout, so we can decide whether\\nto kill it, or just save that for later diagnostics.\\n\\nI'm interested in helping the original goal happen. Dumping an EXPLAIN,\\nwithout ANALYZE info, is not at all interesting since it has no value for\\nimmediate action or post-facto diagnosis, sorry to say - making it happen\\nfor every backend just makes it even less useful.\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\n<http://www.2ndquadrant.com/>\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\nOn 25 September 2015 at 12:13, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote: I now believe that use of ProcessInterrupts() in the recently proposed design as well as manipulation of proc latch due to use of shared memory queue are major blockers.In order to simplify things up, I've taken a step back and looked again at the auto_explain contrib module. I now propose the most simple thing possible in my opinion: a new GUC option for auto_explain. It will make every backend, in which the module is loaded via *_preload_libraries mechanism or using CREATE EXTENSION/LOAD commands, to actively publish the plans of queries in dynamic shared memory as long as auto_explain.publish_plans is turned on.The greatest part for me, is that this approach doesn't require handling of signals and is isolated in an external module, so it can be readily used with the current server versions, no need to wait for >= 9.6.This is a major change of direction, so the thread title no longer applies at all.The requirement is to be able to see the output of EXPLAIN ANALYZE for a running process. Ideally, we would dump the diagnostic output for any process that runs longer than a specific timeout, so we can decide whether to kill it, or just save that for later diagnostics.I'm interested in helping the original goal happen. Dumping an EXPLAIN, without ANALYZE info, is not at all interesting since it has no value for immediate action or post-facto diagnosis, sorry to say - making it happen for every backend just makes it even less useful.-- Simon Riggs http://www.2ndQuadrant.com/PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\",\n \"msg_date\": \"Tue, 29 Sep 2015 12:01:43 -0500\",\n \"msg_from\": \"Simon Riggs <simon@2ndQuadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 29, 2015 at 7:01 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n\\n> On 25 September 2015 at 12:13, Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de> wrote:\\n>\\n>\\n>> I now believe that use of ProcessInterrupts() in the recently proposed\\n>> design as well as manipulation of proc latch due to use of shared memory\\n>> queue are major blockers.\\n>>\\n>> In order to simplify things up, I've taken a step back and looked again\\n>> at the auto_explain contrib module. I now propose the most simple thing\\n>> possible in my opinion: a new GUC option for auto_explain. It will make\\n>> every backend, in which the module is loaded via *_preload_libraries\\n>> mechanism or using CREATE EXTENSION/LOAD commands, to actively publish the\\n>> plans of queries in dynamic shared memory as long as\\n>> auto_explain.publish_plans is turned on.\\n>>\\n>> The greatest part for me, is that this approach doesn't require handling\\n>> of signals and is isolated in an external module, so it can be readily used\\n>> with the current server versions, no need to wait for >= 9.6.\\n>>\\n>\\n> This is a major change of direction, so the thread title no longer applies\\n> at all.\\n>\\n> The requirement is to be able to see the output of EXPLAIN ANALYZE for a\\n> running process. Ideally, we would dump the diagnostic output for any\\n> process that runs longer than a specific timeout, so we can decide whether\\n> to kill it, or just save that for later diagnostics.\\n>\\n> I'm interested in helping the original goal happen. Dumping an EXPLAIN,\\n> without ANALYZE info, is not at all interesting since it has no value for\\n> immediate action or post-facto diagnosis, sorry to say - making it happen\\n> for every backend just makes it even less useful.\\n>\\n\\nThis is not a change of the direction, but rather of the approach. Hitting\\na process with a signal and hoping it will produce a meaningful response in\\nall circumstances without disrupting its current task was way too naive.\\nI'd really want to make this work with ANALYZE, just not as the first\\nstep. I believe this approach can be extended to include instrumentation\\nsupport (obviously we will not be able to contain this in the auto_explain\\nmodule).\\n\\n--\\nAlex\\n\\nOn Tue, Sep 29, 2015 at 7:01 PM, Simon Riggs <simon@2ndquadrant.com> wrote:On 25 September 2015 at 12:13, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote: I now believe that use of ProcessInterrupts() in the recently proposed design as well as manipulation of proc latch due to use of shared memory queue are major blockers.In order to simplify things up, I've taken a step back and looked again at the auto_explain contrib module. I now propose the most simple thing possible in my opinion: a new GUC option for auto_explain. It will make every backend, in which the module is loaded via *_preload_libraries mechanism or using CREATE EXTENSION/LOAD commands, to actively publish the plans of queries in dynamic shared memory as long as auto_explain.publish_plans is turned on.The greatest part for me, is that this approach doesn't require handling of signals and is isolated in an external module, so it can be readily used with the current server versions, no need to wait for >= 9.6.This is a major change of direction, so the thread title no longer applies at all.The requirement is to be able to see the output of EXPLAIN ANALYZE for a running process. Ideally, we would dump the diagnostic output for any process that runs longer than a specific timeout, so we can decide whether to kill it, or just save that for later diagnostics.I'm interested in helping the original goal happen. Dumping an EXPLAIN, without ANALYZE info, is not at all interesting since it has no value for immediate action or post-facto diagnosis, sorry to say - making it happen for every backend just makes it even less useful.This is not a change of the direction, but rather of the approach. Hitting a process with a signal and hoping it will produce a meaningful response in all circumstances without disrupting its current task was way too naive. I'd really want to make this work with ANALYZE, just not as the first step. I believe this approach can be extended to include instrumentation support (obviously we will not be able to contain this in the auto_explain module).--Alex\",\n \"msg_date\": \"Tue, 29 Sep 2015 19:52:46 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On 29 September 2015 at 12:52, Shulgin, Oleksandr <\\noleksandr.shulgin@zalando.de> wrote:\\n\\n\\n> Hitting a process with a signal and hoping it will produce a meaningful\\n> response in all circumstances without disrupting its current task was way\\n> too naive.\\n>\\n\\nHmm, I would have to disagree, sorry. For me the problem was dynamically\\nallocating everything at the time the signal is received and getting into\\nproblems when that caused errors.\\n\\n* INIT - Allocate N areas of memory for use by queries, which can be\\nexpanded/contracted as needed. Keep a freelist of structures.\\n* OBSERVER - When requested, gain exclusive access to a diagnostic area,\\nthen allocate the designated process to that area, then send a signal\\n* QUERY - When signal received dump an EXPLAIN ANALYZE to the allocated\\ndiagnostic area, (set flag to show complete, set latch on observer)\\n* OBSERVER - process data in diagnostic area and then release area for use\\nby next observation\\n\\nIf the EXPLAIN ANALYZE doesn't fit into the diagnostic chunk, LOG it as a\\nproblem and copy data only up to the size defined. Any other ERRORs that\\nare caused by this process cause it to fail normally.\\n\\nThat allows the observer to be another backend, or it allows the query\\nprocess to perform self-observation based upon a timeout (e.g. >1 hour) or\\na row limit (e.g. when an optimizer estimate is seen to be badly wrong).\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\n<http://www.2ndquadrant.com/>\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\nOn 29 September 2015 at 12:52, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote: Hitting a process with a signal and hoping it will produce a meaningful response in all circumstances without disrupting its current task was way too naive. Hmm, I would have to disagree, sorry. For me the problem was dynamically allocating everything at the time the signal is received and getting into problems when that caused errors.* INIT - Allocate N areas of memory for use by queries, which can be expanded/contracted as needed. Keep a freelist of structures.* OBSERVER - When requested, gain exclusive access to a diagnostic area, then allocate the designated process to that area, then send a signal* QUERY - When signal received dump an EXPLAIN ANALYZE to the allocated diagnostic area, (set flag to show complete, set latch on observer)* OBSERVER - process data in diagnostic area and then release area for use by next observationIf the EXPLAIN ANALYZE doesn't fit into the diagnostic chunk, LOG it as a problem and copy data only up to the size defined. Any other ERRORs that are caused by this process cause it to fail normally.That allows the observer to be another backend, or it allows the query process to perform self-observation based upon a timeout (e.g. >1 hour) or a row limit (e.g. when an optimizer estimate is seen to be badly wrong).-- Simon Riggs http://www.2ndQuadrant.com/PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\",\n \"msg_date\": \"Tue, 29 Sep 2015 13:34:12 -0500\",\n \"msg_from\": \"Simon Riggs <simon@2ndQuadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 29, 2015 at 8:34 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n\\n> On 29 September 2015 at 12:52, Shulgin, Oleksandr <\\n> oleksandr.shulgin@zalando.de> wrote:\\n>\\n>\\n>> Hitting a process with a signal and hoping it will produce a meaningful\\n>> response in all circumstances without disrupting its current task was way\\n>> too naive.\\n>>\\n>\\n> Hmm, I would have to disagree, sorry. For me the problem was dynamically\\n> allocating everything at the time the signal is received and getting into\\n> problems when that caused errors.\\n>\\n\\nWhat I mean is that we need to move the actual EXPLAIN run out of\\nProcessInterrupts(). It can be still fine to trigger the communication\\nwith a signal.\\n\\n* INIT - Allocate N areas of memory for use by queries, which can be\\n> expanded/contracted as needed. Keep a freelist of structures.\\n> * OBSERVER - When requested, gain exclusive access to a diagnostic area,\\n> then allocate the designated process to that area, then send a signal\\n> * QUERY - When signal received dump an EXPLAIN ANALYZE to the allocated\\n> diagnostic area, (set flag to show complete, set latch on observer)\\n> * OBSERVER - process data in diagnostic area and then release area for use\\n> by next observation\\n>\\n> If the EXPLAIN ANALYZE doesn't fit into the diagnostic chunk, LOG it as a\\n> problem and copy data only up to the size defined. Any other ERRORs that\\n> are caused by this process cause it to fail normally.\\n>\\n\\nDo you envision problems if we do this with a newly allocated DSM every\\ntime instead of pre-allocated area? This will have to revert the workflow,\\nbecause only the QUERY knows the required segment size:\\n\\nOBSERVER - sends a signal and waits for its proc latch to be set\\nQUERY - when signal is received allocates a DSM just big enough to fit the\\nEXPLAIN plan, then locates the OBSERVER(s) and sets its latch (or their\\nlatches)\\n\\nThe EXPLAIN plan should already be produced somewhere in the executor, to\\navoid calling into explain.c from ProcessInterrupts().\\n\\nThat allows the observer to be another backend, or it allows the query\\n> process to perform self-observation based upon a timeout (e.g. >1 hour) or\\n> a row limit (e.g. when an optimizer estimate is seen to be badly wrong).\\n>\\n\\nDo you think there is one single best place in the executor code where such\\na check could be added? I have very little idea about that.\\n\\n--\\nAlex\\n\\nOn Tue, Sep 29, 2015 at 8:34 PM, Simon Riggs <simon@2ndquadrant.com> wrote:On 29 September 2015 at 12:52, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote: Hitting a process with a signal and hoping it will produce a meaningful response in all circumstances without disrupting its current task was way too naive. Hmm, I would have to disagree, sorry. For me the problem was dynamically allocating everything at the time the signal is received and getting into problems when that caused errors.What I mean is that we need to move the actual EXPLAIN run out of ProcessInterrupts(). It can be still fine to trigger the communication with a signal.* INIT - Allocate N areas of memory for use by queries, which can be expanded/contracted as needed. Keep a freelist of structures.* OBSERVER - When requested, gain exclusive access to a diagnostic area, then allocate the designated process to that area, then send a signal* QUERY - When signal received dump an EXPLAIN ANALYZE to the allocated diagnostic area, (set flag to show complete, set latch on observer)* OBSERVER - process data in diagnostic area and then release area for use by next observationIf the EXPLAIN ANALYZE doesn't fit into the diagnostic chunk, LOG it as a problem and copy data only up to the size defined. Any other ERRORs that are caused by this process cause it to fail normally.Do you envision problems if we do this with a newly allocated DSM every time instead of pre-allocated area? This will have to revert the workflow, because only the QUERY knows the required segment size:OBSERVER - sends a signal and waits for its proc latch to be setQUERY - when signal is received allocates a DSM just big enough to fit the EXPLAIN plan, then locates the OBSERVER(s) and sets its latch (or their latches)The EXPLAIN plan should already be produced somewhere in the executor, to avoid calling into explain.c from ProcessInterrupts().That allows the observer to be another backend, or it allows the query process to perform self-observation based upon a timeout (e.g. >1 hour) or a row limit (e.g. when an optimizer estimate is seen to be badly wrong).Do you think there is one single best place in the executor code where such a check could be added? I have very little idea about that.--Alex\",\n \"msg_date\": \"Tue, 29 Sep 2015 21:52:10 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On 29 September 2015 at 20:52, Shulgin, Oleksandr <\\noleksandr.shulgin@zalando.de> wrote:\\n\\n> On Tue, Sep 29, 2015 at 8:34 PM, Simon Riggs <simon@2ndquadrant.com>\\n> wrote:\\n>\\n>> On 29 September 2015 at 12:52, Shulgin, Oleksandr <\\n>> oleksandr.shulgin@zalando.de> wrote:\\n>>\\n>>\\n>>> Hitting a process with a signal and hoping it will produce a meaningful\\n>>> response in all circumstances without disrupting its current task was way\\n>>> too naive.\\n>>>\\n>>\\n>> Hmm, I would have to disagree, sorry. For me the problem was dynamically\\n>> allocating everything at the time the signal is received and getting into\\n>> problems when that caused errors.\\n>>\\n>\\n> What I mean is that we need to move the actual EXPLAIN run out of\\n> ProcessInterrupts(). It can be still fine to trigger the communication\\n> with a signal.\\n>\\n\\nGood\\n\\n\\n> * INIT - Allocate N areas of memory for use by queries, which can be\\n>> expanded/contracted as needed. Keep a freelist of structures.\\n>> * OBSERVER - When requested, gain exclusive access to a diagnostic area,\\n>> then allocate the designated process to that area, then send a signal\\n>> * QUERY - When signal received dump an EXPLAIN ANALYZE to the allocated\\n>> diagnostic area, (set flag to show complete, set latch on observer)\\n>> * OBSERVER - process data in diagnostic area and then release area for\\n>> use by next observation\\n>>\\n>> If the EXPLAIN ANALYZE doesn't fit into the diagnostic chunk, LOG it as a\\n>> problem and copy data only up to the size defined. Any other ERRORs that\\n>> are caused by this process cause it to fail normally.\\n>>\\n>\\n> Do you envision problems if we do this with a newly allocated DSM every\\n> time instead of pre-allocated area? This will have to revert the workflow,\\n> because only the QUERY knows the required segment size:\\n>\\n\\nThat's too fiddly; we need to keep it simple by using just fixed sizes.\\n\\n\\n> OBSERVER - sends a signal and waits for its proc latch to be set\\n> QUERY - when signal is received allocates a DSM just big enough to fit the\\n> EXPLAIN plan, then locates the OBSERVER(s) and sets its latch (or their\\n> latches)\\n>\\n> The EXPLAIN plan should already be produced somewhere in the executor, to\\n> avoid calling into explain.c from ProcessInterrupts().\\n>\\n> That allows the observer to be another backend, or it allows the query\\n>> process to perform self-observation based upon a timeout (e.g. >1 hour) or\\n>> a row limit (e.g. when an optimizer estimate is seen to be badly wrong).\\n>>\\n>\\n> Do you think there is one single best place in the executor code where\\n> such a check could be added? I have very little idea about that.\\n>\\n\\n Fairly simple.\\n\\nMain problem is knowing how to handle nested calls to the executor.\\n\\nI'll look at the patch.\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\n<http://www.2ndquadrant.com/>\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\nOn 29 September 2015 at 20:52, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote:On Tue, Sep 29, 2015 at 8:34 PM, Simon Riggs <simon@2ndquadrant.com> wrote:On 29 September 2015 at 12:52, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote: Hitting a process with a signal and hoping it will produce a meaningful response in all circumstances without disrupting its current task was way too naive. Hmm, I would have to disagree, sorry. For me the problem was dynamically allocating everything at the time the signal is received and getting into problems when that caused errors.What I mean is that we need to move the actual EXPLAIN run out of ProcessInterrupts(). It can be still fine to trigger the communication with a signal.Good * INIT - Allocate N areas of memory for use by queries, which can be expanded/contracted as needed. Keep a freelist of structures.* OBSERVER - When requested, gain exclusive access to a diagnostic area, then allocate the designated process to that area, then send a signal* QUERY - When signal received dump an EXPLAIN ANALYZE to the allocated diagnostic area, (set flag to show complete, set latch on observer)* OBSERVER - process data in diagnostic area and then release area for use by next observationIf the EXPLAIN ANALYZE doesn't fit into the diagnostic chunk, LOG it as a problem and copy data only up to the size defined. Any other ERRORs that are caused by this process cause it to fail normally.Do you envision problems if we do this with a newly allocated DSM every time instead of pre-allocated area? This will have to revert the workflow, because only the QUERY knows the required segment size:That's too fiddly; we need to keep it simple by using just fixed sizes. OBSERVER - sends a signal and waits for its proc latch to be setQUERY - when signal is received allocates a DSM just big enough to fit the EXPLAIN plan, then locates the OBSERVER(s) and sets its latch (or their latches)The EXPLAIN plan should already be produced somewhere in the executor, to avoid calling into explain.c from ProcessInterrupts().That allows the observer to be another backend, or it allows the query process to perform self-observation based upon a timeout (e.g. >1 hour) or a row limit (e.g. when an optimizer estimate is seen to be badly wrong).Do you think there is one single best place in the executor code where such a check could be added? I have very little idea about that. Fairly simple.Main problem is knowing how to handle nested calls to the executor.I'll look at the patch.-- Simon Riggs http://www.2ndQuadrant.com/PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\",\n \"msg_date\": \"Tue, 29 Sep 2015 21:59:20 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndQuadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 29, 2015 at 1:52 PM, Shulgin, Oleksandr\\n<oleksandr.shulgin@zalando.de> wrote:\\n> This is not a change of the direction, but rather of the approach. Hitting\\n> a process with a signal and hoping it will produce a meaningful response in\\n> all circumstances without disrupting its current task was way too naive.\\n\\nI think that's exactly right. It's not safe to do much anything from\\na signal handler, and while ProcessInterrupts() is a very\\nsubstantially safer, the set of things that can be safely done there\\nis still awfully restricted. You have to cope with the fact that the\\nfunction you just interrupted may be doing anything at all, and if you\\nchange anything before returning, you may knock over the apple cart.\\nJust as bad, the state you inherit may not be very sane: we call\\nProcessInterrupts() from LOTS of places and there is absolutely no\\nguarantee that every one of those places has the data structures that\\nyou need to run EXPLAIN ANALYZE in a sane state.\\n\\nI haven't looked at the new patch specifically so I don't have an\\nopinion on that at this time.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 2 Oct 2015 16:25:45 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 29, 2015 at 7:52 PM, Shulgin, Oleksandr <\\noleksandr.shulgin@zalando.de> wrote:\\n\\n>\\n> This is not a change of the direction, but rather of the approach.\\n> Hitting a process with a signal and hoping it will produce a meaningful\\n> response in all circumstances without disrupting its current task was way\\n> too naive. I'd really want to make this work with ANALYZE, just not as the\\n> first step. I believe this approach can be extended to include\\n> instrumentation support (obviously we will not be able to contain this in\\n> the auto_explain module).\\n>\\n\\nI was thinking about this and what seems to be the biggest problem is when\\nto actually turn the feature on. It seems unlikely that someone will want\\nto enable it unconditionally. Enabling per-backend also doesn't seem to be\\na good approach because you don't know if the next query you'd like to look\\nat is going to run in this exact backend.\\n\\nWhat might be actually usable is poking pg_stat_statements for queryid to\\ndecide if we need to do explain (and possibly analyze). We could make it\\nso that the explain is produced for any query that is known to run longer\\nthan certain configurable threshold on average (or we can provide for\\nenabling this explicitly per entry in pg_stat_statements). Then the\\ninterested client can go and do pg_explain_backend() on the pid.\\n\\nIf we would also track the plan total costs, we could do some predictions\\nso that if the same query comes along and is planned with total cost\\nexceeding the recorded average the configurable amount of percent, then we\\nenable explain.\\n\\nDoes this make sense to you? Does this make a good argument for merging\\npg_stat_statements and auto_explain into core?\\n\\n--\\nAlex\\n\\nOn Tue, Sep 29, 2015 at 7:52 PM, Shulgin, Oleksandr <oleksandr.shulgin@zalando.de> wrote:This is not a change of the direction, but rather of the approach. Hitting a process with a signal and hoping it will produce a meaningful response in all circumstances without disrupting its current task was way too naive. I'd really want to make this work with ANALYZE, just not as the first step. I believe this approach can be extended to include instrumentation support (obviously we will not be able to contain this in the auto_explain module).I was thinking about this and what seems to be the biggest problem is when to actually turn the feature on. It seems unlikely that someone will want to enable it unconditionally. Enabling per-backend also doesn't seem to be a good approach because you don't know if the next query you'd like to look at is going to run in this exact backend.What might be actually usable is poking pg_stat_statements for queryid to decide if we need to do explain (and possibly analyze). We could make it so that the explain is produced for any query that is known to run longer than certain configurable threshold on average (or we can provide for enabling this explicitly per entry in pg_stat_statements). Then the interested client can go and do pg_explain_backend() on the pid.If we would also track the plan total costs, we could do some predictions so that if the same query comes along and is planned with total cost exceeding the recorded average the configurable amount of percent, then we enable explain.Does this make sense to you? Does this make a good argument for merging pg_stat_statements and auto_explain into core?--Alex\",\n \"msg_date\": \"Thu, 15 Oct 2015 11:16:01 +0200\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de> writes:\\n> I was thinking about this and what seems to be the biggest problem is when\\n> to actually turn the feature on. It seems unlikely that someone will want\\n> to enable it unconditionally. Enabling per-backend also doesn't seem to be\\n> a good approach because you don't know if the next query you'd like to look\\n> at is going to run in this exact backend.\\n\\nCheck.\\n\\n> What might be actually usable is poking pg_stat_statements for queryid to\\n> decide if we need to do explain (and possibly analyze).\\n\\nHm, interesting thought.\\n\\n> Does this make sense to you? Does this make a good argument for merging\\n> pg_stat_statements and auto_explain into core?\\n\\nI'd say more that it's a good argument for moving this feature out to\\none of those extensions, or perhaps building a third extension that\\ndepends on both of those. TBH, none of this stuff smells to me like\\nsomething that ought to be in core.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 15 Oct 2015 09:42:47 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-10-15 15:42 GMT+02:00 Tom Lane <tgl@sss.pgh.pa.us>:\\n\\n> \\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de> writes:\\n> > I was thinking about this and what seems to be the biggest problem is\\n> when\\n> > to actually turn the feature on. It seems unlikely that someone will\\n> want\\n> > to enable it unconditionally. Enabling per-backend also doesn't seem to\\n> be\\n> > a good approach because you don't know if the next query you'd like to\\n> look\\n> > at is going to run in this exact backend.\\n>\\n> Check.\\n>\\n> > What might be actually usable is poking pg_stat_statements for queryid to\\n> > decide if we need to do explain (and possibly analyze).\\n>\\n> Hm, interesting thought.\\n>\\n> > Does this make sense to you? Does this make a good argument for merging\\n> > pg_stat_statements and auto_explain into core?\\n>\\n> I'd say more that it's a good argument for moving this feature out to\\n> one of those extensions, or perhaps building a third extension that\\n> depends on both of those. TBH, none of this stuff smells to me like\\n> something that ought to be in core.\\n>\\n\\nThere are few features, that I would to see in core:\\n\\n1. possibility to get full SQL string\\n2. possibility to get state string\\n\\nWe can speak how to do it well.\\n\\nRegards\\n\\nPavel\\n\\n\\n\\n>\\n> regards, tom lane\\n>\\n\\n2015-10-15 15:42 GMT+02:00 Tom Lane <tgl@sss.pgh.pa.us>:\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de> writes:\\n> I was thinking about this and what seems to be the biggest problem is when\\n> to actually turn the feature on. It seems unlikely that someone will want\\n> to enable it unconditionally. Enabling per-backend also doesn't seem to be\\n> a good approach because you don't know if the next query you'd like to look\\n> at is going to run in this exact backend.\\n\\nCheck.\\n\\n> What might be actually usable is poking pg_stat_statements for queryid to\\n> decide if we need to do explain (and possibly analyze).\\n\\nHm, interesting thought.\\n\\n> Does this make sense to you? Does this make a good argument for merging\\n> pg_stat_statements and auto_explain into core?\\n\\nI'd say more that it's a good argument for moving this feature out to\\none of those extensions, or perhaps building a third extension that\\ndepends on both of those. TBH, none of this stuff smells to me like\\nsomething that ought to be in core.There are few features, that I would to see in core:1. possibility to get full SQL string2. possibility to get state stringWe can speak how to do it well.RegardsPavel \\n\\n regards, tom lane\",\n \"msg_date\": \"Thu, 15 Oct 2015 16:04:08 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"Hello,\\n\\nOn 15/10/2015 16:04, Pavel Stehule wrote:\\n> \\n> \\n> 2015-10-15 15:42 GMT+02:00 Tom Lane <tgl@sss.pgh.pa.us\\n> <mailto:tgl@sss.pgh.pa.us>>:\\n> \\n> \\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de\\n> <mailto:oleksandr.shulgin@zalando.de>> writes:\\n> > I was thinking about this and what seems to be the biggest problem is when\\n> > to actually turn the feature on. It seems unlikely that someone will want\\n> > to enable it unconditionally. Enabling per-backend also doesn't seem to be\\n> > a good approach because you don't know if the next query you'd like to look\\n> > at is going to run in this exact backend.\\n> \\n> Check.\\n> \\n> > What might be actually usable is poking pg_stat_statements for queryid to\\n> > decide if we need to do explain (and possibly analyze).\\n> \\n> Hm, interesting thought.\\n> \\n> > Does this make sense to you? Does this make a good argument for merging\\n> > pg_stat_statements and auto_explain into core?\\n> \\n> I'd say more that it's a good argument for moving this feature out to\\n> one of those extensions, or perhaps building a third extension that\\n> depends on both of those. TBH, none of this stuff smells to me like\\n> something that ought to be in core.\\n> \\n> \\n> There are few features, that I would to see in core:\\n> \\n> 1. possibility to get full SQL string\\n> 2. possibility to get state string\\n> \\n> We can speak how to do it well.\\n> \\n\\nI registered as reviewer on this, but after reading the whole thread for\\nthe second time, it's still not clear to me if the last two submitted\\npatches (0001-Add-auto_explain.publish_plans.patch and\\n0002-Add-SHM-table-of-contents-to-the-explain-DSM.patch) are still\\nneeded reviews, since multiple refactoring ideas and objections have\\nbeen raised since.\\n\\n\\nRegards.\\n\\n-- \\nJulien Rouhaud\\nhttp://dalibo.com - http://dalibo.org\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 30 Nov 2015 22:27:24 +0100\",\n \"msg_from\": \"Julien Rouhaud <julien.rouhaud@dalibo.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and\\n signals\"\n },\n {\n \"msg_contents\": \"On 30 November 2015 at 22:27, Julien Rouhaud <julien.rouhaud@dalibo.com>\\nwrote:\\n\\n\\n> I registered as reviewer on this, but after reading the whole thread for\\n> the second time, it's still not clear to me if the last two submitted\\n> patches (0001-Add-auto_explain.publish_plans.patch and\\n> 0002-Add-SHM-table-of-contents-to-the-explain-DSM.patch) are still\\n> needed reviews, since multiple refactoring ideas and objections have\\n> been raised since.\\n>\\n\\nI looked into it more deeply and decided partial EXPLAINs aren't very\\nuseful yet.\\n\\nI've got some thoughts around that which I'll publish when I have more\\ntime. I suggest this is a good idea, just needs some serious\\ncommitter-love, so we should bounce this for now.\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\n<http://www.2ndquadrant.com/>\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\nOn 30 November 2015 at 22:27, Julien Rouhaud <julien.rouhaud@dalibo.com> wrote: I registered as reviewer on this, but after reading the whole thread for\\nthe second time, it's still not clear to me if the last two submitted\\npatches (0001-Add-auto_explain.publish_plans.patch and\\n0002-Add-SHM-table-of-contents-to-the-explain-DSM.patch) are still\\nneeded reviews, since multiple refactoring ideas and objections have\\nbeen raised since.I looked into it more deeply and decided partial EXPLAINs aren't very useful yet.I've got some thoughts around that which I'll publish when I have more time. I suggest this is a good idea, just needs some serious committer-love, so we should bounce this for now.-- Simon Riggs http://www.2ndQuadrant.com/PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\",\n \"msg_date\": \"Tue, 1 Dec 2015 00:04:27 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndQuadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Tue, Dec 1, 2015 at 12:04 AM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n\\n> On 30 November 2015 at 22:27, Julien Rouhaud <julien.rouhaud@dalibo.com>\\n> wrote:\\n>\\n>\\n>> I registered as reviewer on this, but after reading the whole thread for\\n>> the second time, it's still not clear to me if the last two submitted\\n>> patches (0001-Add-auto_explain.publish_plans.patch and\\n>> 0002-Add-SHM-table-of-contents-to-the-explain-DSM.patch) are still\\n>> needed reviews, since multiple refactoring ideas and objections have\\n>> been raised since.\\n>>\\n>\\n> I looked into it more deeply and decided partial EXPLAINs aren't very\\n> useful yet.\\n>\\n> I've got some thoughts around that which I'll publish when I have more\\n> time. I suggest this is a good idea, just needs some serious\\n> committer-love, so we should bounce this for now.\\n>\\n\\nI have the plans to make something from this on top of pg_stat_statements\\nand auto_explain, as I've mentioned last time. The next iteration will be\\nbased on the two latest patches above, so it still makes sense to review\\nthem.\\n\\nAs for EXPLAIN ANALYZE support, it will require changes to core, but this\\ncan be done separately.\\n\\n--\\nAlex\\n\\nOn Tue, Dec 1, 2015 at 12:04 AM, Simon Riggs <simon@2ndquadrant.com> wrote:On 30 November 2015 at 22:27, Julien Rouhaud <julien.rouhaud@dalibo.com> wrote: I registered as reviewer on this, but after reading the whole thread for\\nthe second time, it's still not clear to me if the last two submitted\\npatches (0001-Add-auto_explain.publish_plans.patch and\\n0002-Add-SHM-table-of-contents-to-the-explain-DSM.patch) are still\\nneeded reviews, since multiple refactoring ideas and objections have\\nbeen raised since.I looked into it more deeply and decided partial EXPLAINs aren't very useful yet.I've got some thoughts around that which I'll publish when I have more time. I suggest this is a good idea, just needs some serious committer-love, so we should bounce this for now.I have the plans to make something from this on top of pg_stat_statements and auto_explain, as I've mentioned last time. The next iteration will be based on the two latest patches above, so it still makes sense to review them.As for EXPLAIN ANALYZE support, it will require changes to core, but this can be done separately.--Alex\",\n \"msg_date\": \"Tue, 1 Dec 2015 10:34:32 +0100\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nOn 12/01/2015 10:34 AM, Shulgin, Oleksandr wrote:\\n>\\n> I have the plans to make something from this on top of\\n> pg_stat_statements and auto_explain, as I've mentioned last time. The\\n> next iteration will be based on the two latest patches above, so it\\n> still makes sense to review them.\\n>\\n> As for EXPLAIN ANALYZE support, it will require changes to core, but\\n> this can be done separately.\\n\\nI'm re-reading the thread, and I have to admit I'm utterly confused what \\nis the current plan, what features it's supposed to provide and whether \\nit will solve the use case I'm most interested in. Oleksandr, could you \\nplease post a summary explaining that?\\n\\nMy use case for this functionality is debugging of long-running queries, \\nparticularly getting EXPLAIN ANALYZE for them. In such cases I either \\ncan't run the EXPLAIN ANALYZE manually because it will either run \\nforever (just like the query) and may not be the same (e.g. due to \\nrecent ANALYZE). So we need to extract the data from the process \\nexecuting the query.\\n\\nI'm not essentially opposed to doing this in an extension (better an \\nextension than nothing), but I don't quite see how you could to do that \\nfrom pg_stat_statements or auto_explain. AFAIK both extensions merely \\nuse hooks before/after the executor, and therefore can't do anything in \\nbetween (while the query is actually running).\\n\\nPerhaps you don't intend to solve this particular use case? Which use \\ncases are you aiming to solve, then? Could you explain?\\n\\n\\nMaybe all we need to do is add another hook somewhere in the executor, \\nand push the explain analyze into pg_stat_statements once in a while, \\nentirely eliminating the need for inter-process communication (signals, \\nqueues, ...).\\n\\nI'm pretty sure we don't need this for \\\"short\\\" queries, because in those \\ncases we have other means to get the explain analyze (e.g. running the \\nquery again or auto_explain). So I can imagine having a rather high \\nthreshold (say, 60 seconds or even more), and we'd only push the explain \\nanalyze after crossing it. And then we'd only update it once in a while \\n- say, again every 60 seconds.\\n\\nOf course, this might be configurable by two GUCs:\\n\\n pg_stat_statements.explain_analyze_threshold = 60 # -1 is \\\"off\\\"\\n pg_stat_statements.explain_analyze_refresh = 60\\n\\nFWIW I'd still prefer having \\\"EXPLAIN ANALYZE\\\" in core, but better this \\nthan nothing.\\n\\n\\nregards\\n\\n--\\nTomas Vondra http://www.2ndQuadrant.com\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 16 Dec 2015 20:39:58 +0100\",\n \"msg_from\": \"Tomas Vondra <tomas.vondra@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and\\n signals\"\n },\n {\n \"msg_contents\": \"On Wed, Dec 16, 2015 at 8:39 PM, Tomas Vondra <tomas.vondra@2ndquadrant.com>\\nwrote:\\n\\n> Hi,\\n>\\n> On 12/01/2015 10:34 AM, Shulgin, Oleksandr wrote:\\n>\\n>>\\n>> I have the plans to make something from this on top of\\n>> pg_stat_statements and auto_explain, as I've mentioned last time. The\\n>> next iteration will be based on the two latest patches above, so it\\n>> still makes sense to review them.\\n>>\\n>> As for EXPLAIN ANALYZE support, it will require changes to core, but\\n>> this can be done separately.\\n>>\\n>\\n> I'm re-reading the thread, and I have to admit I'm utterly confused what\\n> is the current plan, what features it's supposed to provide and whether it\\n> will solve the use case I'm most interested in. Oleksandr, could you please\\n> post a summary explaining that?\\n>\\n> My use case for this functionality is debugging of long-running queries,\\n> particularly getting EXPLAIN ANALYZE for them. In such cases I either can't\\n> run the EXPLAIN ANALYZE manually because it will either run forever (just\\n> like the query) and may not be the same (e.g. due to recent ANALYZE). So we\\n> need to extract the data from the process executing the query.\\n>\\n> I'm not essentially opposed to doing this in an extension (better an\\n> extension than nothing), but I don't quite see how you could to do that\\n> from pg_stat_statements or auto_explain. AFAIK both extensions merely use\\n> hooks before/after the executor, and therefore can't do anything in between\\n> (while the query is actually running).\\n>\\n> Perhaps you don't intend to solve this particular use case? Which use\\n> cases are you aiming to solve, then? Could you explain?\\n>\\n\\nHi Tomas.\\n\\nThanks for your interest in this patch!\\n\\nMy motivation is the same as your use case: having a long-running query, be\\nable to look inside this exact query run by this exact backend.\\n\\nI admit the evolution of ideas in this patch can be very confusing: we were\\ntrying a number of different approaches, w/o thinking deeply on the\\nimplications, just to have a proof of concept.\\n\\nMaybe all we need to do is add another hook somewhere in the executor, and\\n> push the explain analyze into pg_stat_statements once in a while, entirely\\n> eliminating the need for inter-process communication (signals, queues, ...).\\n>\\n> I'm pretty sure we don't need this for \\\"short\\\" queries, because in those\\n> cases we have other means to get the explain analyze (e.g. running the\\n> query again or auto_explain). So I can imagine having a rather high\\n> threshold (say, 60 seconds or even more), and we'd only push the explain\\n> analyze after crossing it. And then we'd only update it once in a while -\\n> say, again every 60 seconds.\\n>\\n> Of course, this might be configurable by two GUCs:\\n>\\n> pg_stat_statements.explain_analyze_threshold = 60 # -1 is \\\"off\\\"\\n> pg_stat_statements.explain_analyze_refresh = 60\\n>\\n> FWIW I'd still prefer having \\\"EXPLAIN ANALYZE\\\" in core, but better this\\n> than nothing.\\n>\\n\\nYes, this is how pg_stat_statements idea comes into play: even if we\\nimplement support for online EXPLAIN ANALYZE, enabling it for every query\\nis an overkill, but if you don't enable it from the query start, there is\\nno way to enable it later on as the query has already progressed. So in\\norder to know for which queries it makes sense to enable this feature, we\\nneed to know what is the query's expected run time, thus pg_stat_statements\\nseems like a natural place to obtain this information and/or trigger the\\nbehavior.\\n\\nI'm also all for simplification of the underlying communication mechanism:\\nshared memory queues are neat, but not necessarily the best way to handle\\nit. As for the use of signals: I believe this was a red herring, it will\\nmake the code much less fragile if the progressing backend itself will\\npublish intermediary EXPLAIN ANALYZE reports for other backends to read.\\n\\nThe EXPLAIN (w/o ANALYZE) we can do completely as an extension: no core\\nsupport required. To enable ANALYZE it will require a little hacking\\naround Instrumentation methods: otherwise the Explain functions just crash\\nwhen run in the middle of the query.\\n\\nHope that makes it clear.\\n\\n--\\nAlex\\n\\nOn Wed, Dec 16, 2015 at 8:39 PM, Tomas Vondra <tomas.vondra@2ndquadrant.com> wrote:Hi,\\n\\nOn 12/01/2015 10:34 AM, Shulgin, Oleksandr wrote:\\n\\n\\nI have the plans to make something from this on top of\\npg_stat_statements and auto_explain, as I've mentioned last time. The\\nnext iteration will be based on the two latest patches above, so it\\nstill makes sense to review them.\\n\\nAs for EXPLAIN ANALYZE support, it will require changes to core, but\\nthis can be done separately.\\n\\n\\nI'm re-reading the thread, and I have to admit I'm utterly confused what is the current plan, what features it's supposed to provide and whether it will solve the use case I'm most interested in. Oleksandr, could you please post a summary explaining that?\\n\\nMy use case for this functionality is debugging of long-running queries, particularly getting EXPLAIN ANALYZE for them. In such cases I either can't run the EXPLAIN ANALYZE manually because it will either run forever (just like the query) and may not be the same (e.g. due to recent ANALYZE). So we need to extract the data from the process executing the query.\\n\\nI'm not essentially opposed to doing this in an extension (better an extension than nothing), but I don't quite see how you could to do that from pg_stat_statements or auto_explain. AFAIK both extensions merely use hooks before/after the executor, and therefore can't do anything in between (while the query is actually running).\\n\\nPerhaps you don't intend to solve this particular use case? Which use cases are you aiming to solve, then? Could you explain?Hi Tomas.Thanks for your interest in this patch!My motivation is the same as your use case: having a long-running query, be able to look inside this exact query run by this exact backend.I admit the evolution of ideas in this patch can be very confusing: we were trying a number of different approaches, w/o thinking deeply on the implications, just to have a proof of concept.\\nMaybe all we need to do is add another hook somewhere in the executor, and push the explain analyze into pg_stat_statements once in a while, entirely eliminating the need for inter-process communication (signals, queues, ...).\\n\\nI'm pretty sure we don't need this for \\\"short\\\" queries, because in those cases we have other means to get the explain analyze (e.g. running the query again or auto_explain). So I can imagine having a rather high threshold (say, 60 seconds or even more), and we'd only push the explain analyze after crossing it. And then we'd only update it once in a while - say, again every 60 seconds.\\n\\nOf course, this might be configurable by two GUCs:\\n\\n pg_stat_statements.explain_analyze_threshold = 60 # -1 is \\\"off\\\"\\n pg_stat_statements.explain_analyze_refresh = 60\\n\\nFWIW I'd still prefer having \\\"EXPLAIN ANALYZE\\\" in core, but better this than nothing.Yes, this is how pg_stat_statements idea comes into play: even if we implement support for online EXPLAIN ANALYZE, enabling it for every query is an overkill, but if you don't enable it from the query start, there is no way to enable it later on as the query has already progressed. So in order to know for which queries it makes sense to enable this feature, we need to know what is the query's expected run time, thus pg_stat_statements seems like a natural place to obtain this information and/or trigger the behavior.I'm also all for simplification of the underlying communication mechanism: shared memory queues are neat, but not necessarily the best way to handle it. As for the use of signals: I believe this was a red herring, it will make the code much less fragile if the progressing backend itself will publish intermediary EXPLAIN ANALYZE reports for other backends to read.The EXPLAIN (w/o ANALYZE) we can do completely as an extension: no core support required. To enable ANALYZE it will require a little hacking around Instrumentation methods: otherwise the Explain functions just crash when run in the middle of the query.Hope that makes it clear.--Alex\",\n \"msg_date\": \"Thu, 17 Dec 2015 10:45:32 +0100\",\n \"msg_from\": \"\\\"Shulgin, Oleksandr\\\" <oleksandr.shulgin@zalando.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Thu, Dec 17, 2015 at 6:45 PM, Shulgin, Oleksandr\\n<oleksandr.shulgin@zalando.de> wrote:\\n> On Wed, Dec 16, 2015 at 8:39 PM, Tomas Vondra <tomas.vondra@2ndquadrant.com>\\n> wrote:\\n>> On 12/01/2015 10:34 AM, Shulgin, Oleksandr wrote:\\n>>>\\n>>>\\n>>> I have the plans to make something from this on top of\\n>>> pg_stat_statements and auto_explain, as I've mentioned last time. The\\n>>> next iteration will be based on the two latest patches above, so it\\n>>> still makes sense to review them.\\n>>>\\n>>> As for EXPLAIN ANALYZE support, it will require changes to core, but\\n>>> this can be done separately.\\n>>\\n>> I'm re-reading the thread, and I have to admit I'm utterly confused what\\n>> is the current plan, what features it's supposed to provide and whether it\\n>> will solve the use case I'm most interested in. Oleksandr, could you please\\n>> post a summary explaining that?\\n>>\\n>> My use case for this functionality is debugging of long-running queries,\\n>> particularly getting EXPLAIN ANALYZE for them. In such cases I either can't\\n>> run the EXPLAIN ANALYZE manually because it will either run forever (just\\n>> like the query) and may not be the same (e.g. due to recent ANALYZE). So we\\n>> need to extract the data from the process executing the query.\\n>>\\n>> I'm not essentially opposed to doing this in an extension (better an\\n>> extension than nothing), but I don't quite see how you could to do that from\\n>> pg_stat_statements or auto_explain. AFAIK both extensions merely use hooks\\n>> before/after the executor, and therefore can't do anything in between (while\\n>> the query is actually running).\\n>>\\n>> Perhaps you don't intend to solve this particular use case? Which use\\n>> cases are you aiming to solve, then? Could you explain?\\n>\\n> Thanks for your interest in this patch!\\n>\\n> My motivation is the same as your use case: having a long-running query, be\\n> able to look inside this exact query run by this exact backend.\\n>\\n> I admit the evolution of ideas in this patch can be very confusing: we were\\n> trying a number of different approaches, w/o thinking deeply on the\\n> implications, just to have a proof of concept.\\n\\nIt's great to see ideas of concepts and things to help address those\\nissues, at least we are agreeing that there is a hole in the\\ninstrumentation and that it would be nice to fill it with something.\\nStill, it is not completely clear which approach would be taken. Is it\\nfair to mark the current patch as returned with feedback then?\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 24 Dec 2015 11:23:02 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"2015-12-24 3:23 GMT+01:00 Michael Paquier <michael.paquier@gmail.com>:\\n\\n> On Thu, Dec 17, 2015 at 6:45 PM, Shulgin, Oleksandr\\n> <oleksandr.shulgin@zalando.de> wrote:\\n> > On Wed, Dec 16, 2015 at 8:39 PM, Tomas Vondra <\\n> tomas.vondra@2ndquadrant.com>\\n> > wrote:\\n> >> On 12/01/2015 10:34 AM, Shulgin, Oleksandr wrote:\\n> >>>\\n> >>>\\n> >>> I have the plans to make something from this on top of\\n> >>> pg_stat_statements and auto_explain, as I've mentioned last time. The\\n> >>> next iteration will be based on the two latest patches above, so it\\n> >>> still makes sense to review them.\\n> >>>\\n> >>> As for EXPLAIN ANALYZE support, it will require changes to core, but\\n> >>> this can be done separately.\\n> >>\\n> >> I'm re-reading the thread, and I have to admit I'm utterly confused what\\n> >> is the current plan, what features it's supposed to provide and whether\\n> it\\n> >> will solve the use case I'm most interested in. Oleksandr, could you\\n> please\\n> >> post a summary explaining that?\\n> >>\\n> >> My use case for this functionality is debugging of long-running queries,\\n> >> particularly getting EXPLAIN ANALYZE for them. In such cases I either\\n> can't\\n> >> run the EXPLAIN ANALYZE manually because it will either run forever\\n> (just\\n> >> like the query) and may not be the same (e.g. due to recent ANALYZE).\\n> So we\\n> >> need to extract the data from the process executing the query.\\n> >>\\n> >> I'm not essentially opposed to doing this in an extension (better an\\n> >> extension than nothing), but I don't quite see how you could to do that\\n> from\\n> >> pg_stat_statements or auto_explain. AFAIK both extensions merely use\\n> hooks\\n> >> before/after the executor, and therefore can't do anything in between\\n> (while\\n> >> the query is actually running).\\n> >>\\n> >> Perhaps you don't intend to solve this particular use case? Which use\\n> >> cases are you aiming to solve, then? Could you explain?\\n> >\\n> > Thanks for your interest in this patch!\\n> >\\n> > My motivation is the same as your use case: having a long-running query,\\n> be\\n> > able to look inside this exact query run by this exact backend.\\n> >\\n> > I admit the evolution of ideas in this patch can be very confusing: we\\n> were\\n> > trying a number of different approaches, w/o thinking deeply on the\\n> > implications, just to have a proof of concept.\\n>\\n> It's great to see ideas of concepts and things to help address those\\n> issues, at least we are agreeing that there is a hole in the\\n> instrumentation and that it would be nice to fill it with something.\\n> Still, it is not completely clear which approach would be taken. Is it\\n> fair to mark the current patch as returned with feedback then?\\n>\\n\\n+1\\n\\nPavel\\n\\n\\n> --\\n> Michael\\n>\\n\\n2015-12-24 3:23 GMT+01:00 Michael Paquier <michael.paquier@gmail.com>:On Thu, Dec 17, 2015 at 6:45 PM, Shulgin, Oleksandr\\n<oleksandr.shulgin@zalando.de> wrote:\\n> On Wed, Dec 16, 2015 at 8:39 PM, Tomas Vondra <tomas.vondra@2ndquadrant.com>\\n> wrote:\\n>> On 12/01/2015 10:34 AM, Shulgin, Oleksandr wrote:\\n>>>\\n>>>\\n>>> I have the plans to make something from this on top of\\n>>> pg_stat_statements and auto_explain, as I've mentioned last time. The\\n>>> next iteration will be based on the two latest patches above, so it\\n>>> still makes sense to review them.\\n>>>\\n>>> As for EXPLAIN ANALYZE support, it will require changes to core, but\\n>>> this can be done separately.\\n>>\\n>> I'm re-reading the thread, and I have to admit I'm utterly confused what\\n>> is the current plan, what features it's supposed to provide and whether it\\n>> will solve the use case I'm most interested in. Oleksandr, could you please\\n>> post a summary explaining that?\\n>>\\n>> My use case for this functionality is debugging of long-running queries,\\n>> particularly getting EXPLAIN ANALYZE for them. In such cases I either can't\\n>> run the EXPLAIN ANALYZE manually because it will either run forever (just\\n>> like the query) and may not be the same (e.g. due to recent ANALYZE). So we\\n>> need to extract the data from the process executing the query.\\n>>\\n>> I'm not essentially opposed to doing this in an extension (better an\\n>> extension than nothing), but I don't quite see how you could to do that from\\n>> pg_stat_statements or auto_explain. AFAIK both extensions merely use hooks\\n>> before/after the executor, and therefore can't do anything in between (while\\n>> the query is actually running).\\n>>\\n>> Perhaps you don't intend to solve this particular use case? Which use\\n>> cases are you aiming to solve, then? Could you explain?\\n>\\n> Thanks for your interest in this patch!\\n>\\n> My motivation is the same as your use case: having a long-running query, be\\n> able to look inside this exact query run by this exact backend.\\n>\\n> I admit the evolution of ideas in this patch can be very confusing: we were\\n> trying a number of different approaches, w/o thinking deeply on the\\n> implications, just to have a proof of concept.\\n\\nIt's great to see ideas of concepts and things to help address those\\nissues, at least we are agreeing that there is a hole in the\\ninstrumentation and that it would be nice to fill it with something.\\nStill, it is not completely clear which approach would be taken. Is it\\nfair to mark the current patch as returned with feedback then?+1Pavel \\n--\\nMichael\",\n \"msg_date\": \"Thu, 24 Dec 2015 05:57:10 +0100\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n },\n {\n \"msg_contents\": \"On Thu, Dec 24, 2015 at 1:57 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:\\n>\\n>\\n> 2015-12-24 3:23 GMT+01:00 Michael Paquier <michael.paquier@gmail.com>:\\n>>\\n>> On Thu, Dec 17, 2015 at 6:45 PM, Shulgin, Oleksandr\\n>> <oleksandr.shulgin@zalando.de> wrote:\\n>> > On Wed, Dec 16, 2015 at 8:39 PM, Tomas Vondra\\n>> > <tomas.vondra@2ndquadrant.com>\\n>> > wrote:\\n>> >> On 12/01/2015 10:34 AM, Shulgin, Oleksandr wrote:\\n>> >>>\\n>> >>>\\n>> >>> I have the plans to make something from this on top of\\n>> >>> pg_stat_statements and auto_explain, as I've mentioned last time. The\\n>> >>> next iteration will be based on the two latest patches above, so it\\n>> >>> still makes sense to review them.\\n>> >>>\\n>> >>> As for EXPLAIN ANALYZE support, it will require changes to core, but\\n>> >>> this can be done separately.\\n>> >>\\n>> >> I'm re-reading the thread, and I have to admit I'm utterly confused\\n>> >> what\\n>> >> is the current plan, what features it's supposed to provide and whether\\n>> >> it\\n>> >> will solve the use case I'm most interested in. Oleksandr, could you\\n>> >> please\\n>> >> post a summary explaining that?\\n>> >>\\n>> >> My use case for this functionality is debugging of long-running\\n>> >> queries,\\n>> >> particularly getting EXPLAIN ANALYZE for them. In such cases I either\\n>> >> can't\\n>> >> run the EXPLAIN ANALYZE manually because it will either run forever\\n>> >> (just\\n>> >> like the query) and may not be the same (e.g. due to recent ANALYZE).\\n>> >> So we\\n>> >> need to extract the data from the process executing the query.\\n>> >>\\n>> >> I'm not essentially opposed to doing this in an extension (better an\\n>> >> extension than nothing), but I don't quite see how you could to do that\\n>> >> from\\n>> >> pg_stat_statements or auto_explain. AFAIK both extensions merely use\\n>> >> hooks\\n>> >> before/after the executor, and therefore can't do anything in between\\n>> >> (while\\n>> >> the query is actually running).\\n>> >>\\n>> >> Perhaps you don't intend to solve this particular use case? Which use\\n>> >> cases are you aiming to solve, then? Could you explain?\\n>> >\\n>> > Thanks for your interest in this patch!\\n>> >\\n>> > My motivation is the same as your use case: having a long-running query,\\n>> > be\\n>> > able to look inside this exact query run by this exact backend.\\n>> >\\n>> > I admit the evolution of ideas in this patch can be very confusing: we\\n>> > were\\n>> > trying a number of different approaches, w/o thinking deeply on the\\n>> > implications, just to have a proof of concept.\\n>>\\n>> It's great to see ideas of concepts and things to help address those\\n>> issues, at least we are agreeing that there is a hole in the\\n>> instrumentation and that it would be nice to fill it with something.\\n>> Still, it is not completely clear which approach would be taken. Is it\\n>> fair to mark the current patch as returned with feedback then?\\n>\\n>\\n> +1\\n\\nSo, done this way. We could always move it to next CF if someone\\nwishes to move on. But at this point that would be a different\\napproach than what was proposed first..\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 24 Dec 2015 16:36:48 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: On-demand running query plans using auto_explain and signals\"\n }\n]","isConversational":false}}},{"rowIdx":41197,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"The buffer/README section on buffer clean up locks never got updated for\nthe creation of Heap Only Tuples and their associated compaction logic.\n\nI've attached a patch to change the explanation. I'm sure someone can word\nit better than I have.\n\nCheers,\n\nJeff\n\nThe buffer/README section on buffer clean up locks never got updated for the creation of Heap Only Tuples and their associated compaction logic.I've attached a patch to change the explanation. I'm sure someone can word it better than I have.Cheers,Jeff","msg_date":"Sat, 29 Aug 2015 11:45:07 -0700","msg_from":"Jeff Janes <jeff.janes@gmail.com>","msg_from_op":true,"msg_subject":"buffer README is out of date"},{"msg_contents":"On Sat, Aug 29, 2015 at 11:45 AM, Jeff Janes <jeff.janes@gmail.com> wrote:\n\n> The buffer/README section on buffer clean up locks never got updated for\n> the creation of Heap Only Tuples and their associated compaction logic.\n>\n> I've attached a patch to change the explanation. I'm sure someone can\n> word it better than I have.\n>\n\n...particularly if I won't let you see my wording.\n\nActually attached this time.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Sat, 29 Aug 2015 12:21:31 -0700","msg_from":"Jeff Janes <jeff.janes@gmail.com>","msg_from_op":true,"msg_subject":"Re: buffer README is out of date"},{"msg_contents":"On 8/29/15 2:21 PM, Jeff Janes wrote:\n> The buffer/README section on buffer clean up locks never got updated\n> for the creation of Heap Only Tuples and their associated compaction\n> logic.\n>\n> I've attached a patch to change the explanation. I'm sure someone\n> can word it better than I have.\n\n> ! Obtaining the necessary lock is done by the bufmgr routines\n> ! LockBufferForCleanup() or ConditionalLockBufferForCleanup().\n> ! They first get an exclusive lock and then check to see if the shared pin\n> ! count is currently 1. If not, ConditionalLockBufferForCleanup() releases\n> ! the exclusive lock and then returns false, while LockBufferForCleanup()\n> ! releases the exclusive lock (but not the caller's pin) and waits until\n> ! signaled by another backend, whereupon it tries again. The signal will\n> ! occur when UnpinBuffer decrements the shared pin count to 1. As\n\nI don't think that's true. If 2 other backends have a pin then AFAIK \nyou'd wake up twice. There's also this comment in LockBufferForCleanup:\n\n/*\n * Remove flag marking us as waiter. Normally this will not be set\n * anymore, but ProcWaitForSignal() can return for other signals as\n * well. We take care to only reset the flag if we're the waiter, as\n * theoretically another backend could have started waiting. That's\n * impossible with the current usages due to table level locking, but\n * better be safe.\n */\n\n> ! indicated above, this operation might have to wait a good while before\n> ! it acquires lock, but that shouldn't matter much for concurrent VACUUM.\n> ! The current implementation only supports a single waiter for pin-count-1\n> ! on any particular shared buffer. This is enough for VACUUM's use, since\n> ! we don't allow multiple VACUUMs concurrently on a single relation anyway.\n> ! Anyone wishing to obtain a clean up lock outside of a VACUUM must use\n> ! the conditional variant of the function.\n\nThat last statement should possibly be worded more strongly or just \nremoved. If someone thinks they want to use this mechanism for something \nother than VACUUM there's probably a lot of other things to consider \nbeyond just buffer locking.\n-- \nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\nExperts in Analytics, Data Architecture and PostgreSQL\nData in Trouble? Get it in Treble! http://BlueTreble.com\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sat, 29 Aug 2015 15:27:15 -0500","msg_from":"Jim Nasby <Jim.Nasby@BlueTreble.com>","msg_from_op":false,"msg_subject":"Re: buffer README is out of date"},{"msg_contents":"On Sat, Aug 29, 2015 at 1:27 PM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:\n\n> On 8/29/15 2:21 PM, Jeff Janes wrote:\n>\n>> The buffer/README section on buffer clean up locks never got updated\n>> for the creation of Heap Only Tuples and their associated compaction\n>> logic.\n>>\n>> I've attached a patch to change the explanation. I'm sure someone\n>> can word it better than I have.\n>>\n>\n> ! Obtaining the necessary lock is done by the bufmgr routines\n>> ! LockBufferForCleanup() or ConditionalLockBufferForCleanup().\n>> ! They first get an exclusive lock and then check to see if the shared pin\n>> ! count is currently 1. If not, ConditionalLockBufferForCleanup()\n>> releases\n>> ! the exclusive lock and then returns false, while LockBufferForCleanup()\n>> ! releases the exclusive lock (but not the caller's pin) and waits until\n>> ! signaled by another backend, whereupon it tries again. The signal will\n>> ! occur when UnpinBuffer decrements the shared pin count to 1. As\n>>\n>\n> I don't think that's true. If 2 other backends have a pin then AFAIK you'd\n> wake up twice. There's also this comment in LockBufferForCleanup:\n>\n> /*\n> * Remove flag marking us as waiter. Normally this will not be set\n> * anymore, but ProcWaitForSignal() can return for other signals as\n> * well. We take care to only reset the flag if we're the waiter, as\n> * theoretically another backend could have started waiting. That's\n> * impossible with the current usages due to table level locking, but\n> * better be safe.\n> */\n>\n\nIf 2 other backends have a pin, only the last one to drop it should do the\nwaking. I don't see a way they could both try to do the waking, the\ninterlock on the buffer header seems to prevent that. But if it did, that\nwould just be another way you could have a spurious wake-up, which can\nalready happen for other reasons. I don't think the spurious wake up needs\nto be documented in the higher level README file.\n\n\n>\n> ! indicated above, this operation might have to wait a good while before\n>> ! it acquires lock, but that shouldn't matter much for concurrent VACUUM.\n>> ! The current implementation only supports a single waiter for pin-count-1\n>> ! on any particular shared buffer. This is enough for VACUUM's use, since\n>> ! we don't allow multiple VACUUMs concurrently on a single relation\n>> anyway.\n>> ! Anyone wishing to obtain a clean up lock outside of a VACUUM must use\n>> ! the conditional variant of the function.\n>>\n>\n> That last statement should possibly be worded more strongly or just\n> removed. If someone thinks they want to use this mechanism for something\n> other than VACUUM there's probably a lot of other things to consider beyond\n> just buffer locking.\n\n\nBut the point of this is that HOT updates are **already** doing this\noutside of VACUUM. That is why the README is out of date.\n\nCheers,\n\nJeff\n\nOn Sat, Aug 29, 2015 at 1:27 PM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:On 8/29/15 2:21 PM, Jeff Janes wrote:\n\n The buffer/README section on buffer clean up locks never got updated\n for the creation of Heap Only Tuples and their associated compaction\n logic.\n\n I've attached a patch to change the explanation. I'm sure someone\n can word it better than I have.\n\n\n\n! Obtaining the necessary lock is done by the bufmgr routines\n! LockBufferForCleanup() or ConditionalLockBufferForCleanup().\n! They first get an exclusive lock and then check to see if the shared pin\n! count is currently 1. If not, ConditionalLockBufferForCleanup() releases\n! the exclusive lock and then returns false, while LockBufferForCleanup()\n! releases the exclusive lock (but not the caller's pin) and waits until\n! signaled by another backend, whereupon it tries again. The signal will\n! occur when UnpinBuffer decrements the shared pin count to 1. As\n\n\nI don't think that's true. If 2 other backends have a pin then AFAIK you'd wake up twice. There's also this comment in LockBufferForCleanup:\n\n/*\n * Remove flag marking us as waiter. Normally this will not be set\n * anymore, but ProcWaitForSignal() can return for other signals as\n * well. We take care to only reset the flag if we're the waiter, as\n * theoretically another backend could have started waiting. That's\n * impossible with the current usages due to table level locking, but\n * better be safe.\n */If 2 other backends have a pin, only the last one to drop it should do the waking. I don't see a way they could both try to do the waking, the interlock on the buffer header seems to prevent that. But if it did, that would just be another way you could have a spurious wake-up, which can already happen for other reasons. I don't think the spurious wake up needs to be documented in the higher level README file. \n\n\n! indicated above, this operation might have to wait a good while before\n! it acquires lock, but that shouldn't matter much for concurrent VACUUM.\n! The current implementation only supports a single waiter for pin-count-1\n! on any particular shared buffer. This is enough for VACUUM's use, since\n! we don't allow multiple VACUUMs concurrently on a single relation anyway.\n! Anyone wishing to obtain a clean up lock outside of a VACUUM must use\n! the conditional variant of the function.\n\n\nThat last statement should possibly be worded more strongly or just removed. If someone thinks they want to use this mechanism for something other than VACUUM there's probably a lot of other things to consider beyond just buffer locking.But the point of this is that HOT updates are **already** doing this outside of VACUUM. That is why the README is out of date.Cheers,Jeff","msg_date":"Sat, 29 Aug 2015 15:52:51 -0700","msg_from":"Jeff Janes <jeff.janes@gmail.com>","msg_from_op":true,"msg_subject":"Re: buffer README is out of date"},{"msg_contents":"On 8/29/15 5:52 PM, Jeff Janes wrote:\n> ! Obtaining the necessary lock is done by the bufmgr routines\n> ! LockBufferForCleanup() or ConditionalLockBufferForCleanup().\n> ! They first get an exclusive lock and then check to see if the\n> shared pin\n> ! count is currently 1. If not,\n> ConditionalLockBufferForCleanup() releases\n> ! the exclusive lock and then returns false, while\n> LockBufferForCleanup()\n> ! releases the exclusive lock (but not the caller's pin) and\n> waits until\n> ! signaled by another backend, whereupon it tries again. The\n> signal will\n> ! occur when UnpinBuffer decrements the shared pin count to 1. As\n>\n>\n> I don't think that's true. If 2 other backends have a pin then AFAIK\n> you'd wake up twice. There's also this comment in LockBufferForCleanup:\n>\n> /*\n> * Remove flag marking us as waiter. Normally this will not be set\n> * anymore, but ProcWaitForSignal() can return for other signals as\n> * well. We take care to only reset the flag if we're the waiter, as\n> * theoretically another backend could have started waiting. That's\n> * impossible with the current usages due to table level locking, but\n> * better be safe.\n> */\n>\n>\n> If 2 other backends have a pin, only the last one to drop it should do\n> the waking. I don't see a way they could both try to do the waking, the\n> interlock on the buffer header seems to prevent that. But if it did,\n> that would just be another way you could have a spurious wake-up, which\n> can already happen for other reasons. I don't think the spurious wake\n> up needs to be documented in the higher level README file.\n\nMy concern is someone will read too much into \"signal will occur ... \ncount to 1\" and think there's no other ways to be woken up. I realize \nI'm being pedantic here, but given the nasty race condition bugs we've \nhad lately maybe it's warranted.\n-- \nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\nExperts in Analytics, Data Architecture and PostgreSQL\nData in Trouble? Get it in Treble! http://BlueTreble.com\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 00:33:26 -0500","msg_from":"Jim Nasby <Jim.Nasby@BlueTreble.com>","msg_from_op":false,"msg_subject":"Re: buffer README is out of date"},{"msg_contents":"On Tue, Sep 01, 2015 at 12:33:26AM -0500, Jim Nasby wrote:\n> On 8/29/15 5:52 PM, Jeff Janes wrote:\n> >If 2 other backends have a pin, only the last one to drop it should do\n> >the waking. I don't see a way they could both try to do the waking, the\n> >interlock on the buffer header seems to prevent that. But if it did,\n> >that would just be another way you could have a spurious wake-up, which\n> >can already happen for other reasons. I don't think the spurious wake\n> >up needs to be documented in the higher level README file.\n> \n> My concern is someone will read too much into \"signal will occur ... count\n> to 1\" and think there's no other ways to be woken up. I realize I'm being\n> pedantic here, but given the nasty race condition bugs we've had lately\n> maybe it's warranted.\n\nFair concern. I'm not too worried in this instance, because I can't think of\na choice the caller would make differently based on such a misunderstanding.\nPrecise wakeup conditions are not really part of the LockBufferForCleanup()\nAPI contract[1]. The submission seems to move this README in the right\ndirection, so I committed it with some changes:\n\n1. s/clean up/cleanup/\n2. remove patch-added trailing whitespace\n3. re-add to the first sentence a citation of rule #5\n4. say that recovery can use LockBufferForCleanup(); heap_xlog_clean() does so\n\n\n[1] If there's more to improve, it might be to move finer implementation\ndetails out of the README and into code comments.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Fri, 1 Jan 2016 21:58:59 -0500","msg_from":"Noah Misch <noah@leadboat.com>","msg_from_op":false,"msg_subject":"Re: buffer README is out of date"}],"string":"[\n {\n \"msg_contents\": \"The buffer/README section on buffer clean up locks never got updated for\\nthe creation of Heap Only Tuples and their associated compaction logic.\\n\\nI've attached a patch to change the explanation. I'm sure someone can word\\nit better than I have.\\n\\nCheers,\\n\\nJeff\\n\\nThe buffer/README section on buffer clean up locks never got updated for the creation of Heap Only Tuples and their associated compaction logic.I've attached a patch to change the explanation. I'm sure someone can word it better than I have.Cheers,Jeff\",\n \"msg_date\": \"Sat, 29 Aug 2015 11:45:07 -0700\",\n \"msg_from\": \"Jeff Janes <jeff.janes@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"buffer README is out of date\"\n },\n {\n \"msg_contents\": \"On Sat, Aug 29, 2015 at 11:45 AM, Jeff Janes <jeff.janes@gmail.com> wrote:\\n\\n> The buffer/README section on buffer clean up locks never got updated for\\n> the creation of Heap Only Tuples and their associated compaction logic.\\n>\\n> I've attached a patch to change the explanation. I'm sure someone can\\n> word it better than I have.\\n>\\n\\n...particularly if I won't let you see my wording.\\n\\nActually attached this time.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Sat, 29 Aug 2015 12:21:31 -0700\",\n \"msg_from\": \"Jeff Janes <jeff.janes@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: buffer README is out of date\"\n },\n {\n \"msg_contents\": \"On 8/29/15 2:21 PM, Jeff Janes wrote:\\n> The buffer/README section on buffer clean up locks never got updated\\n> for the creation of Heap Only Tuples and their associated compaction\\n> logic.\\n>\\n> I've attached a patch to change the explanation. I'm sure someone\\n> can word it better than I have.\\n\\n> ! Obtaining the necessary lock is done by the bufmgr routines\\n> ! LockBufferForCleanup() or ConditionalLockBufferForCleanup().\\n> ! They first get an exclusive lock and then check to see if the shared pin\\n> ! count is currently 1. If not, ConditionalLockBufferForCleanup() releases\\n> ! the exclusive lock and then returns false, while LockBufferForCleanup()\\n> ! releases the exclusive lock (but not the caller's pin) and waits until\\n> ! signaled by another backend, whereupon it tries again. The signal will\\n> ! occur when UnpinBuffer decrements the shared pin count to 1. As\\n\\nI don't think that's true. If 2 other backends have a pin then AFAIK \\nyou'd wake up twice. There's also this comment in LockBufferForCleanup:\\n\\n/*\\n * Remove flag marking us as waiter. Normally this will not be set\\n * anymore, but ProcWaitForSignal() can return for other signals as\\n * well. We take care to only reset the flag if we're the waiter, as\\n * theoretically another backend could have started waiting. That's\\n * impossible with the current usages due to table level locking, but\\n * better be safe.\\n */\\n\\n> ! indicated above, this operation might have to wait a good while before\\n> ! it acquires lock, but that shouldn't matter much for concurrent VACUUM.\\n> ! The current implementation only supports a single waiter for pin-count-1\\n> ! on any particular shared buffer. This is enough for VACUUM's use, since\\n> ! we don't allow multiple VACUUMs concurrently on a single relation anyway.\\n> ! Anyone wishing to obtain a clean up lock outside of a VACUUM must use\\n> ! the conditional variant of the function.\\n\\nThat last statement should possibly be worded more strongly or just \\nremoved. If someone thinks they want to use this mechanism for something \\nother than VACUUM there's probably a lot of other things to consider \\nbeyond just buffer locking.\\n-- \\nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\\nExperts in Analytics, Data Architecture and PostgreSQL\\nData in Trouble? Get it in Treble! http://BlueTreble.com\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 29 Aug 2015 15:27:15 -0500\",\n \"msg_from\": \"Jim Nasby <Jim.Nasby@BlueTreble.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: buffer README is out of date\"\n },\n {\n \"msg_contents\": \"On Sat, Aug 29, 2015 at 1:27 PM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:\\n\\n> On 8/29/15 2:21 PM, Jeff Janes wrote:\\n>\\n>> The buffer/README section on buffer clean up locks never got updated\\n>> for the creation of Heap Only Tuples and their associated compaction\\n>> logic.\\n>>\\n>> I've attached a patch to change the explanation. I'm sure someone\\n>> can word it better than I have.\\n>>\\n>\\n> ! Obtaining the necessary lock is done by the bufmgr routines\\n>> ! LockBufferForCleanup() or ConditionalLockBufferForCleanup().\\n>> ! They first get an exclusive lock and then check to see if the shared pin\\n>> ! count is currently 1. If not, ConditionalLockBufferForCleanup()\\n>> releases\\n>> ! the exclusive lock and then returns false, while LockBufferForCleanup()\\n>> ! releases the exclusive lock (but not the caller's pin) and waits until\\n>> ! signaled by another backend, whereupon it tries again. The signal will\\n>> ! occur when UnpinBuffer decrements the shared pin count to 1. As\\n>>\\n>\\n> I don't think that's true. If 2 other backends have a pin then AFAIK you'd\\n> wake up twice. There's also this comment in LockBufferForCleanup:\\n>\\n> /*\\n> * Remove flag marking us as waiter. Normally this will not be set\\n> * anymore, but ProcWaitForSignal() can return for other signals as\\n> * well. We take care to only reset the flag if we're the waiter, as\\n> * theoretically another backend could have started waiting. That's\\n> * impossible with the current usages due to table level locking, but\\n> * better be safe.\\n> */\\n>\\n\\nIf 2 other backends have a pin, only the last one to drop it should do the\\nwaking. I don't see a way they could both try to do the waking, the\\ninterlock on the buffer header seems to prevent that. But if it did, that\\nwould just be another way you could have a spurious wake-up, which can\\nalready happen for other reasons. I don't think the spurious wake up needs\\nto be documented in the higher level README file.\\n\\n\\n>\\n> ! indicated above, this operation might have to wait a good while before\\n>> ! it acquires lock, but that shouldn't matter much for concurrent VACUUM.\\n>> ! The current implementation only supports a single waiter for pin-count-1\\n>> ! on any particular shared buffer. This is enough for VACUUM's use, since\\n>> ! we don't allow multiple VACUUMs concurrently on a single relation\\n>> anyway.\\n>> ! Anyone wishing to obtain a clean up lock outside of a VACUUM must use\\n>> ! the conditional variant of the function.\\n>>\\n>\\n> That last statement should possibly be worded more strongly or just\\n> removed. If someone thinks they want to use this mechanism for something\\n> other than VACUUM there's probably a lot of other things to consider beyond\\n> just buffer locking.\\n\\n\\nBut the point of this is that HOT updates are **already** doing this\\noutside of VACUUM. That is why the README is out of date.\\n\\nCheers,\\n\\nJeff\\n\\nOn Sat, Aug 29, 2015 at 1:27 PM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:On 8/29/15 2:21 PM, Jeff Janes wrote:\\n\\n The buffer/README section on buffer clean up locks never got updated\\n for the creation of Heap Only Tuples and their associated compaction\\n logic.\\n\\n I've attached a patch to change the explanation. I'm sure someone\\n can word it better than I have.\\n\\n\\n\\n! Obtaining the necessary lock is done by the bufmgr routines\\n! LockBufferForCleanup() or ConditionalLockBufferForCleanup().\\n! They first get an exclusive lock and then check to see if the shared pin\\n! count is currently 1. If not, ConditionalLockBufferForCleanup() releases\\n! the exclusive lock and then returns false, while LockBufferForCleanup()\\n! releases the exclusive lock (but not the caller's pin) and waits until\\n! signaled by another backend, whereupon it tries again. The signal will\\n! occur when UnpinBuffer decrements the shared pin count to 1. As\\n\\n\\nI don't think that's true. If 2 other backends have a pin then AFAIK you'd wake up twice. There's also this comment in LockBufferForCleanup:\\n\\n/*\\n * Remove flag marking us as waiter. Normally this will not be set\\n * anymore, but ProcWaitForSignal() can return for other signals as\\n * well. We take care to only reset the flag if we're the waiter, as\\n * theoretically another backend could have started waiting. That's\\n * impossible with the current usages due to table level locking, but\\n * better be safe.\\n */If 2 other backends have a pin, only the last one to drop it should do the waking. I don't see a way they could both try to do the waking, the interlock on the buffer header seems to prevent that. But if it did, that would just be another way you could have a spurious wake-up, which can already happen for other reasons. I don't think the spurious wake up needs to be documented in the higher level README file. \\n\\n\\n! indicated above, this operation might have to wait a good while before\\n! it acquires lock, but that shouldn't matter much for concurrent VACUUM.\\n! The current implementation only supports a single waiter for pin-count-1\\n! on any particular shared buffer. This is enough for VACUUM's use, since\\n! we don't allow multiple VACUUMs concurrently on a single relation anyway.\\n! Anyone wishing to obtain a clean up lock outside of a VACUUM must use\\n! the conditional variant of the function.\\n\\n\\nThat last statement should possibly be worded more strongly or just removed. If someone thinks they want to use this mechanism for something other than VACUUM there's probably a lot of other things to consider beyond just buffer locking.But the point of this is that HOT updates are **already** doing this outside of VACUUM. That is why the README is out of date.Cheers,Jeff\",\n \"msg_date\": \"Sat, 29 Aug 2015 15:52:51 -0700\",\n \"msg_from\": \"Jeff Janes <jeff.janes@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: buffer README is out of date\"\n },\n {\n \"msg_contents\": \"On 8/29/15 5:52 PM, Jeff Janes wrote:\\n> ! Obtaining the necessary lock is done by the bufmgr routines\\n> ! LockBufferForCleanup() or ConditionalLockBufferForCleanup().\\n> ! They first get an exclusive lock and then check to see if the\\n> shared pin\\n> ! count is currently 1. If not,\\n> ConditionalLockBufferForCleanup() releases\\n> ! the exclusive lock and then returns false, while\\n> LockBufferForCleanup()\\n> ! releases the exclusive lock (but not the caller's pin) and\\n> waits until\\n> ! signaled by another backend, whereupon it tries again. The\\n> signal will\\n> ! occur when UnpinBuffer decrements the shared pin count to 1. As\\n>\\n>\\n> I don't think that's true. If 2 other backends have a pin then AFAIK\\n> you'd wake up twice. There's also this comment in LockBufferForCleanup:\\n>\\n> /*\\n> * Remove flag marking us as waiter. Normally this will not be set\\n> * anymore, but ProcWaitForSignal() can return for other signals as\\n> * well. We take care to only reset the flag if we're the waiter, as\\n> * theoretically another backend could have started waiting. That's\\n> * impossible with the current usages due to table level locking, but\\n> * better be safe.\\n> */\\n>\\n>\\n> If 2 other backends have a pin, only the last one to drop it should do\\n> the waking. I don't see a way they could both try to do the waking, the\\n> interlock on the buffer header seems to prevent that. But if it did,\\n> that would just be another way you could have a spurious wake-up, which\\n> can already happen for other reasons. I don't think the spurious wake\\n> up needs to be documented in the higher level README file.\\n\\nMy concern is someone will read too much into \\\"signal will occur ... \\ncount to 1\\\" and think there's no other ways to be woken up. I realize \\nI'm being pedantic here, but given the nasty race condition bugs we've \\nhad lately maybe it's warranted.\\n-- \\nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\\nExperts in Analytics, Data Architecture and PostgreSQL\\nData in Trouble? Get it in Treble! http://BlueTreble.com\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 00:33:26 -0500\",\n \"msg_from\": \"Jim Nasby <Jim.Nasby@BlueTreble.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: buffer README is out of date\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 01, 2015 at 12:33:26AM -0500, Jim Nasby wrote:\\n> On 8/29/15 5:52 PM, Jeff Janes wrote:\\n> >If 2 other backends have a pin, only the last one to drop it should do\\n> >the waking. I don't see a way they could both try to do the waking, the\\n> >interlock on the buffer header seems to prevent that. But if it did,\\n> >that would just be another way you could have a spurious wake-up, which\\n> >can already happen for other reasons. I don't think the spurious wake\\n> >up needs to be documented in the higher level README file.\\n> \\n> My concern is someone will read too much into \\\"signal will occur ... count\\n> to 1\\\" and think there's no other ways to be woken up. I realize I'm being\\n> pedantic here, but given the nasty race condition bugs we've had lately\\n> maybe it's warranted.\\n\\nFair concern. I'm not too worried in this instance, because I can't think of\\na choice the caller would make differently based on such a misunderstanding.\\nPrecise wakeup conditions are not really part of the LockBufferForCleanup()\\nAPI contract[1]. The submission seems to move this README in the right\\ndirection, so I committed it with some changes:\\n\\n1. s/clean up/cleanup/\\n2. remove patch-added trailing whitespace\\n3. re-add to the first sentence a citation of rule #5\\n4. say that recovery can use LockBufferForCleanup(); heap_xlog_clean() does so\\n\\n\\n[1] If there's more to improve, it might be to move finer implementation\\ndetails out of the README and into code comments.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Fri, 1 Jan 2016 21:58:59 -0500\",\n \"msg_from\": \"Noah Misch <noah@leadboat.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: buffer README is out of date\"\n }\n]","isConversational":false}}},{"rowIdx":41198,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"I have recently increased my public statements about the idea of adding\nhorizontal scaling/sharding to Postgres. I wanted to share with hackers\na timeline of how we got here, and where I think we are going in the\nshort term:\n\n2012-2013: As part of writing my scaling talk\n(http://momjian.us/main/presentations/overview.html#scaling), studying\nOracle RAC, and talking to users, it became clear that an XC-like\narchitecture (sharding) was the only architecture that was going to allow\nfor write scaling.\n\nUsers and conference attendees I talked to were increasingly concerned\nabout the ability of Postgres to scale for high write volumes. They didn't\nnecessarily need that scale now, but they needed to know they could get\nit if they wanted it, and wouldn't need to switch to a new database in\nthe future. This is similar to wanting a car that can get you on a highway\non-ramp fast --- even if you don't need it, you want to know it is there.\n\n2014: I started to shop around the idea that we could use FDWs,\nparallelism, and a transaction/snapshot manager to get XC features\nas built-in to Postgres. (I don't remember where the original idea\ncame from.) It was clear that having separate forks of the source code\nin XC and XL was never going to achieve critical mass --- there just\naren't enough people who need high right scale right now, and the fork\nmaintenance overhead is a huge burden.\n\nI realized that we would never get community acceptance to dump the XC\n(or XL) code needed for sharding into community Postgres, but with FDWs,\nwe could add the features as _part_ of improving FDWs, which would benefit\nFDWs _and_ would be useful for sharding. (We already see some of those\nFDW features in 9.5.)\n\nOctober, 2014: EDB and NTT started working together in the community\nto start improving FDWs as a basis for an FDW-based sharding solution.\nMany of the 9.5 FDW improvements that also benefit sharding were developed\nby a combined EDB/NTT team. The features improved FDWs independent of\nsharding, so they didn't need community buy-in on sharding to get them\naccepted.\n\nJune, 2015: I attended the PGCon sharding unconference session and\nthere was a huge discussion about where we should go with sharding.\nI think the big take-away was that most people liked the FDW approach,\nbut had business/customer reasons for wanting to work on XC or XL because\nthose would be production-ready faster.\n\nJuly, 2015: Oleg Bartunov and his new company Postgres Professional (PP)\nstarted to think about joining the FDW approach, rather than working on\nXL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\nmeeting is scheduled for September 1.\n\nAugust, 2015: While speaking at SFPUG, Citus Data approached me about\njoining the FDW sharding team. They have been invited to the September\n1 meeting, as have the XC and XL people.\n\nOctober, 2015: EDB is sponsoring a free 3-hour summit about FDW sharding\nat the PG-EU conference in Vienna. Everyone is invited, but it is hoped\nmost of the September 1 folks can attend.\n\nFebruary, 2016: Oleg is planning a similar meeting at their February\nMoscow conference.\n\nAnyway, I wanted to explain the work that has been happening around\nsharding. As things move forward, I am increasingly convinced that write\nscaling will be needed soon, that the XC approach is the only reasonable\nway to do it, and that FDWs are the cleanest way to get it into community\nPostgres.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sat, 29 Aug 2015 22:17:58 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Horizontal scalability/sharding"},{"msg_contents":"On 30 August 2015 at 03:17, Bruce Momjian <bruce@momjian.us> wrote:\n\n> I have recently increased my public statements about the idea of adding\n> horizontal scaling/sharding to Postgres.\n\n\nGlad to see it. Many people have been pushing such things for years, so it\nis good to finally see some debate about this on Hackers.\n\n\n> I wanted to share with hackers\n> a timeline of how we got here, and where I think we are going in the\n> short term:\n>\n> 2012-2013: As part of writing my scaling talk\n> (http://momjian.us/main/presentations/overview.html#scaling), studying\n> Oracle RAC, and talking to users, it became clear that an XC-like\n> architecture (sharding) was the only architecture that was going to allow\n> for write scaling.\n>\n\nWhat other architectures were discussed? Where was that discussion?\n\n\n> Users and conference attendees I talked to were increasingly concerned\n> about the ability of Postgres to scale for high write volumes. They didn't\n> necessarily need that scale now, but they needed to know they could get\n> it if they wanted it, and wouldn't need to switch to a new database in\n> the future. This is similar to wanting a car that can get you on a highway\n> on-ramp fast --- even if you don't need it, you want to know it is there.\n>\n\n+1\n\n\n> 2014: I started to shop around the idea that we could use FDWs,\n> parallelism, and a transaction/snapshot manager to get XC features\n> as built-in to Postgres. (I don't remember where the original idea\n> came from.) It was clear that having separate forks of the source code\n> in XC and XL was never going to achieve critical mass --- there just\n> aren't enough people who need high right scale right now, and the fork\n> maintenance overhead is a huge burden.\n>\n\nI personally support the view that we should put scalability features into\nPostgres core, rather than run separate forks.\n\n\n> I realized that we would never get community acceptance to dump the XC\n> (or XL) code needed for sharding into community Postgres\n\n\nHow or why did you realize that? There has never been any such discussion,\nAFAIK. Surely it can be possible to move required subsystems across?\n\n\n> , but with FDWs,\n> we could add the features as _part_ of improving FDWs, which would benefit\n> FDWs _and_ would be useful for sharding. (We already see some of those\n> FDW features in 9.5.)\n>\n\nThat is a huge presumption. Not discussed or technically analyzed in any\nway with the community.\n\n\n> October, 2014: EDB and NTT started working together in the community\n> to start improving FDWs as a basis for an FDW-based sharding solution.\n> Many of the 9.5 FDW improvements that also benefit sharding were developed\n> by a combined EDB/NTT team. The features improved FDWs independent of\n> sharding, so they didn't need community buy-in on sharding to get them\n> accepted.\n>\n> June, 2015: I attended the PGCon sharding unconference session and\n> there was a huge discussion about where we should go with sharding.\n> I think the big take-away was that most people liked the FDW approach,\n> but had business/customer reasons for wanting to work on XC or XL because\n> those would be production-ready faster.\n>\n\nCough, cough. You must surely be joking that \"most people liked the FDW\napproach\"? How did we measure the acceptance of this approach?\n\nWhat actually is the FDW approach? Since its not been written down\nanywhere, or even explained verbally, how can anyone actually agree to it?\n\n\n> July, 2015: Oleg Bartunov and his new company Postgres Professional (PP)\n> started to think about joining the FDW approach, rather than working on\n> XL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\n> meeting is scheduled for September 1.\n>\n\n\n> August, 2015: While speaking at SFPUG, Citus Data approached me about\n> joining the FDW sharding team. They have been invited to the September\n> 1 meeting, as have the XC and XL people.\n>\n\n2ndQuadrant is working in this area, specifically bringing XL 9.5 forwards.\nPlease can invites be posted to myself, Pavan Deolasee and Petr Jelinek\nalso? I'll pass on to others also.\n\nKoichi Suzuki is arranging a meeting in Hong Long for XC/XL discussions.\nPresumably EDB is invited also? If Koichi is a leading organizer of this,\nwhy are there two meetings?\n\nOctober, 2015: EDB is sponsoring a free 3-hour summit about FDW sharding\n> at the PG-EU conference in Vienna. Everyone is invited, but it is hoped\n> most of the September 1 folks can attend.\n>\n\n\n> February, 2016: Oleg is planning a similar meeting at their February\n> Moscow conference.\n>\n\n\n> Anyway, I wanted to explain the work that has been happening around\n> sharding.\n\n\nThanks\n\n\n> As things move forward, I am increasingly convinced that write\n> scaling will be needed soon,\n\n\n+1\n\n\n> that the XC approach is the only reasonable way to do it,\n\n\n\n> and that FDWs are the cleanest way to get it into community\n> Postgres.\n>\n\nThose two things aren't at all obvious to me.\n\nPlease don't presume my opposition. If the technical information were made\npublic, I might understand and agree with \"the FDW approach\", perhaps\nothers also. 2ndQuadrant is certainly happy to become involved in any team\naiming to add features to Postgres core, as long as that makes sense. There\nmay be areas we can all agree upon even if the full architecture remains in\ndoubt.\n\nBefore the community commits to a long term venture together we should see\nthe plan. Like all IT projects, expensive failure is possible and the lack\nof a design is a huge flashing red warning light for me at present. If that\nrequires a meeting of all Developers, why are the meetings for this\nspecifically not happening at the agreed Developer meetings?\n\n-- \nSimon Riggs http://www.2ndQuadrant.com/\n<http://www.2ndquadrant.com/>\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\nOn 30 August 2015 at 03:17, Bruce Momjian <bruce@momjian.us> wrote:I have recently increased my public statements about the idea of adding\nhorizontal scaling/sharding to Postgres. Glad to see it. Many people have been pushing such things for years, so it is good to finally see some debate about this on Hackers. I wanted to share with hackers\na timeline of how we got here, and where I think we are going in the\nshort term:\n\n2012-2013: As part of writing my scaling talk\n(http://momjian.us/main/presentations/overview.html#scaling), studying\nOracle RAC, and talking to users, it became clear that an XC-like\narchitecture (sharding) was the only architecture that was going to allow\nfor write scaling.What other architectures were discussed? Where was that discussion? \nUsers and conference attendees I talked to were increasingly concerned\nabout the ability of Postgres to scale for high write volumes. They didn't\nnecessarily need that scale now, but they needed to know they could get\nit if they wanted it, and wouldn't need to switch to a new database in\nthe future. This is similar to wanting a car that can get you on a highway\non-ramp fast --- even if you don't need it, you want to know it is there.+1 \n2014: I started to shop around the idea that we could use FDWs,\nparallelism, and a transaction/snapshot manager to get XC features\nas built-in to Postgres. (I don't remember where the original idea\ncame from.) It was clear that having separate forks of the source code\nin XC and XL was never going to achieve critical mass --- there just\naren't enough people who need high right scale right now, and the fork\nmaintenance overhead is a huge burden.I personally support the view that we should put scalability features into Postgres core, rather than run separate forks. \nI realized that we would never get community acceptance to dump the XC\n(or XL) code needed for sharding into community PostgresHow or why did you realize that? There has never been any such discussion, AFAIK. Surely it can be possible to move required subsystems across? , but with FDWs,\nwe could add the features as _part_ of improving FDWs, which would benefit\nFDWs _and_ would be useful for sharding. (We already see some of those\nFDW features in 9.5.)That is a huge presumption. Not discussed or technically analyzed in any way with the community. \nOctober, 2014: EDB and NTT started working together in the community\nto start improving FDWs as a basis for an FDW-based sharding solution.\nMany of the 9.5 FDW improvements that also benefit sharding were developed\nby a combined EDB/NTT team. The features improved FDWs independent of\nsharding, so they didn't need community buy-in on sharding to get them\naccepted.\n\nJune, 2015: I attended the PGCon sharding unconference session and\nthere was a huge discussion about where we should go with sharding.\nI think the big take-away was that most people liked the FDW approach,\nbut had business/customer reasons for wanting to work on XC or XL because\nthose would be production-ready faster.Cough, cough. You must surely be joking that \"most people liked the FDW approach\"? How did we measure the acceptance of this approach? What actually is the FDW approach? Since its not been written down anywhere, or even explained verbally, how can anyone actually agree to it? \nJuly, 2015: Oleg Bartunov and his new company Postgres Professional (PP)\nstarted to think about joining the FDW approach, rather than working on\nXL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\nmeeting is scheduled for September 1. \nAugust, 2015: While speaking at SFPUG, Citus Data approached me about\njoining the FDW sharding team. They have been invited to the September\n1 meeting, as have the XC and XL people.2ndQuadrant is working in this area, specifically bringing XL 9.5 forwards. Please can invites be posted to myself, Pavan Deolasee and Petr Jelinek also? I'll pass on to others also.Koichi Suzuki is arranging a meeting in Hong Long for XC/XL discussions. Presumably EDB is invited also? If Koichi is a leading organizer of this, why are there two meetings?\nOctober, 2015: EDB is sponsoring a free 3-hour summit about FDW sharding\nat the PG-EU conference in Vienna. Everyone is invited, but it is hoped\nmost of the September 1 folks can attend. \nFebruary, 2016: Oleg is planning a similar meeting at their February\nMoscow conference. \nAnyway, I wanted to explain the work that has been happening around\nsharding.Thanks As things move forward, I am increasingly convinced that write\nscaling will be needed soon,+1 that the XC approach is the only reasonable way to do it, and that FDWs are the cleanest way to get it into community\nPostgres.Those two things aren't at all obvious to me.Please don't presume my opposition. If the technical information were made public, I might understand and agree with \"the FDW approach\", perhaps others also. 2ndQuadrant is certainly happy to become involved in any team aiming to add features to Postgres core, as long as that makes sense. There may be areas we can all agree upon even if the full architecture remains in doubt.Before the community commits to a long term venture together we should see the plan. Like all IT projects, expensive failure is possible and the lack of a design is a huge flashing red warning light for me at present. If that requires a meeting of all Developers, why are the meetings for this specifically not happening at the agreed Developer meetings?-- Simon Riggs http://www.2ndQuadrant.com/PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services","msg_date":"Sun, 30 Aug 2015 15:31:10 +0100","msg_from":"Simon Riggs <simon@2ndQuadrant.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Sun, Aug 30, 2015 at 5:31 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\n\n> On 30 August 2015 at 03:17, Bruce Momjian <bruce@momjian.us> wrote:\n>\n>> I have recently increased my public statements about the idea of adding\n>> horizontal scaling/sharding to Postgres.\n>\n>\n> Glad to see it. Many people have been pushing such things for years, so it\n> is good to finally see some debate about this on Hackers.\n>\n>\n>> I wanted to share with hackers\n>> a timeline of how we got here, and where I think we are going in the\n>> short term:\n>>\n>> 2012-2013: As part of writing my scaling talk\n>> (http://momjian.us/main/presentations/overview.html#scaling), studying\n>> Oracle RAC, and talking to users, it became clear that an XC-like\n>> architecture (sharding) was the only architecture that was going to allow\n>> for write scaling.\n>>\n>\n> What other architectures were discussed? Where was that discussion?\n>\n>\n>> Users and conference attendees I talked to were increasingly concerned\n>> about the ability of Postgres to scale for high write volumes. They\n>> didn't\n>> necessarily need that scale now, but they needed to know they could get\n>> it if they wanted it, and wouldn't need to switch to a new database in\n>> the future. This is similar to wanting a car that can get you on a\n>> highway\n>> on-ramp fast --- even if you don't need it, you want to know it is there.\n>>\n>\n> +1\n>\n>\n>> 2014: I started to shop around the idea that we could use FDWs,\n>> parallelism, and a transaction/snapshot manager to get XC features\n>> as built-in to Postgres. (I don't remember where the original idea\n>> came from.) It was clear that having separate forks of the source code\n>> in XC and XL was never going to achieve critical mass --- there just\n>> aren't enough people who need high right scale right now, and the fork\n>> maintenance overhead is a huge burden.\n>>\n>\n> I personally support the view that we should put scalability features into\n> Postgres core, rather than run separate forks.\n>\n>\n>> I realized that we would never get community acceptance to dump the XC\n>> (or XL) code needed for sharding into community Postgres\n>\n>\n> How or why did you realize that? There has never been any such discussion,\n> AFAIK. Surely it can be possible to move required subsystems across?\n>\n>\n>> , but with FDWs,\n>> we could add the features as _part_ of improving FDWs, which would benefit\n>> FDWs _and_ would be useful for sharding. (We already see some of those\n>> FDW features in 9.5.)\n>>\n>\n> That is a huge presumption. Not discussed or technically analyzed in any\n> way with the community.\n>\n>\n>> October, 2014: EDB and NTT started working together in the community\n>> to start improving FDWs as a basis for an FDW-based sharding solution.\n>> Many of the 9.5 FDW improvements that also benefit sharding were developed\n>> by a combined EDB/NTT team. The features improved FDWs independent of\n>> sharding, so they didn't need community buy-in on sharding to get them\n>> accepted.\n>>\n>> June, 2015: I attended the PGCon sharding unconference session and\n>> there was a huge discussion about where we should go with sharding.\n>> I think the big take-away was that most people liked the FDW approach,\n>> but had business/customer reasons for wanting to work on XC or XL because\n>> those would be production-ready faster.\n>>\n>\n> Cough, cough. You must surely be joking that \"most people liked the FDW\n> approach\"? How did we measure the acceptance of this approach?\n>\n> What actually is the FDW approach? Since its not been written down\n> anywhere, or even explained verbally, how can anyone actually agree to it?\n>\n>\n>> July, 2015: Oleg Bartunov and his new company Postgres Professional (PP)\n>> started to think about joining the FDW approach, rather than working on\n>> XL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\n>> meeting is scheduled for September 1.\n>>\n>\n>\n\nA little correction about Postgres Professional. We are concentrated on\nidea to have one distributed transaction manager, originally DTM, now we\nhave better name XTM, which is neutral to actual cluster realization. For\nexample, we are testing it with XL, ported to 9.4, but we were planning to\nextend tests to pg_shard, postgres_fdw. My idea was to have at least XTM\ncommitted to 9.6, so all parties could work on their implementation much\neasier.\n\n\n\n> August, 2015: While speaking at SFPUG, Citus Data approached me about\n>> joining the FDW sharding team. They have been invited to the September\n>> 1 meeting, as have the XC and XL people.\n>>\n>\n> 2ndQuadrant is working in this area, specifically bringing XL 9.5\n> forwards. Please can invites be posted to myself, Pavan Deolasee and Petr\n> Jelinek also? I'll pass on to others also.\n>\n> Koichi Suzuki is arranging a meeting in Hong Long for XC/XL discussions.\n> Presumably EDB is invited also? If Koichi is a leading organizer of this,\n> why are there two meetings?\n>\n> October, 2015: EDB is sponsoring a free 3-hour summit about FDW sharding\n>> at the PG-EU conference in Vienna. Everyone is invited, but it is hoped\n>> most of the September 1 folks can attend.\n>>\n>\n>\n>> February, 2016: Oleg is planning a similar meeting at their February\n>> Moscow conference.\n>>\n>\n>\n>> Anyway, I wanted to explain the work that has been happening around\n>> sharding.\n>\n>\n> Thanks\n>\n>\n>> As things move forward, I am increasingly convinced that write\n>> scaling will be needed soon,\n>\n>\n> +1\n>\n>\n>> that the XC approach is the only reasonable way to do it,\n>\n>\n>\n>> and that FDWs are the cleanest way to get it into community\n>> Postgres.\n>>\n>\n> Those two things aren't at all obvious to me.\n>\n> Please don't presume my opposition. If the technical information were made\n> public, I might understand and agree with \"the FDW approach\", perhaps\n> others also. 2ndQuadrant is certainly happy to become involved in any team\n> aiming to add features to Postgres core, as long as that makes sense. There\n> may be areas we can all agree upon even if the full architecture remains in\n> doubt.\n>\n> Before the community commits to a long term venture together we should see\n> the plan. Like all IT projects, expensive failure is possible and the lack\n> of a design is a huge flashing red warning light for me at present. If that\n> requires a meeting of all Developers, why are the meetings for this\n> specifically not happening at the agreed Developer meetings?\n>\n>\nAt PGCon we agreed to have such meeting in Vienna at least. But I think we\nshould be prepared and try to clean all our issues before. It looks like we\nalready out of time,but probably we could meet in Hong Kong ?\n\nHonestly, I still don't know which approach is better, we already played\nwith XL (ported to 9.4) and identified some very strong issues with\ninconsistency, which scared us, especially taking into account how easy we\nfound them. XC people have fixed them, but I'm not sure if they were\nfundamental and if we could construct more sophisticated tests and find\nmore issues in XC/XL. We also a bit disappointed by Huawei position about\nCSN patch, we hoped to use for our XTM. FDW approach has been actively\ncriticized by pg_shard people and that's also made me a bit suspicious. It\nlooks like we are doomed to continue several development forks, so we\ndecided to work on very important common project, XTM, which we hoped could\nbe accepted by all parties and eventually committed to 9.6. Now I see we\nwere right, unfortunately.\n\nAgain, could we organize meeting somewhere in September ? US is not good\nfor us, but other places should be ok. I want to have an agreement at\nleast on XTM. We still are testing various approaches, though. We could\npresent results of our experiments and are open to discussion. It's not\neasy project, but it's something we could do for 9.6.\n\nI'm very glad Bruce started this discussion in -hackers, since it's silly\nto me to participate in both threads :) Let's meet in September !\n\n\n\n> --\n> Simon Riggs http://www.2ndQuadrant.com/\n> <http://www.2ndquadrant.com/>\n> PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n>\n\nOn Sun, Aug 30, 2015 at 5:31 PM, Simon Riggs <simon@2ndquadrant.com> wrote:On 30 August 2015 at 03:17, Bruce Momjian <bruce@momjian.us> wrote:I have recently increased my public statements about the idea of adding\nhorizontal scaling/sharding to Postgres. Glad to see it. Many people have been pushing such things for years, so it is good to finally see some debate about this on Hackers. I wanted to share with hackers\na timeline of how we got here, and where I think we are going in the\nshort term:\n\n2012-2013: As part of writing my scaling talk\n(http://momjian.us/main/presentations/overview.html#scaling), studying\nOracle RAC, and talking to users, it became clear that an XC-like\narchitecture (sharding) was the only architecture that was going to allow\nfor write scaling.What other architectures were discussed? Where was that discussion? \nUsers and conference attendees I talked to were increasingly concerned\nabout the ability of Postgres to scale for high write volumes. They didn't\nnecessarily need that scale now, but they needed to know they could get\nit if they wanted it, and wouldn't need to switch to a new database in\nthe future. This is similar to wanting a car that can get you on a highway\non-ramp fast --- even if you don't need it, you want to know it is there.+1 \n2014: I started to shop around the idea that we could use FDWs,\nparallelism, and a transaction/snapshot manager to get XC features\nas built-in to Postgres. (I don't remember where the original idea\ncame from.) It was clear that having separate forks of the source code\nin XC and XL was never going to achieve critical mass --- there just\naren't enough people who need high right scale right now, and the fork\nmaintenance overhead is a huge burden.I personally support the view that we should put scalability features into Postgres core, rather than run separate forks. \nI realized that we would never get community acceptance to dump the XC\n(or XL) code needed for sharding into community PostgresHow or why did you realize that? There has never been any such discussion, AFAIK. Surely it can be possible to move required subsystems across? , but with FDWs,\nwe could add the features as _part_ of improving FDWs, which would benefit\nFDWs _and_ would be useful for sharding. (We already see some of those\nFDW features in 9.5.)That is a huge presumption. Not discussed or technically analyzed in any way with the community. \nOctober, 2014: EDB and NTT started working together in the community\nto start improving FDWs as a basis for an FDW-based sharding solution.\nMany of the 9.5 FDW improvements that also benefit sharding were developed\nby a combined EDB/NTT team. The features improved FDWs independent of\nsharding, so they didn't need community buy-in on sharding to get them\naccepted.\n\nJune, 2015: I attended the PGCon sharding unconference session and\nthere was a huge discussion about where we should go with sharding.\nI think the big take-away was that most people liked the FDW approach,\nbut had business/customer reasons for wanting to work on XC or XL because\nthose would be production-ready faster.Cough, cough. You must surely be joking that \"most people liked the FDW approach\"? How did we measure the acceptance of this approach? What actually is the FDW approach? Since its not been written down anywhere, or even explained verbally, how can anyone actually agree to it? \nJuly, 2015: Oleg Bartunov and his new company Postgres Professional (PP)\nstarted to think about joining the FDW approach, rather than working on\nXL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\nmeeting is scheduled for September 1. A little correction about Postgres Professional. We are concentrated on \nidea to have one distributed transaction manager, originally DTM, now we\n have better name XTM, which is neutral to actual cluster realization. \nFor example, we are testing it with XL, ported to 9.4, but we were \nplanning to extend tests to pg_shard, postgres_fdw. My idea was to have \nat least XTM committed to 9.6, so all parties could work on their \nimplementation much easier. \nAugust, 2015: While speaking at SFPUG, Citus Data approached me about\njoining the FDW sharding team. They have been invited to the September\n1 meeting, as have the XC and XL people.2ndQuadrant is working in this area, specifically bringing XL 9.5 forwards. Please can invites be posted to myself, Pavan Deolasee and Petr Jelinek also? I'll pass on to others also.Koichi Suzuki is arranging a meeting in Hong Long for XC/XL discussions. Presumably EDB is invited also? If Koichi is a leading organizer of this, why are there two meetings?\nOctober, 2015: EDB is sponsoring a free 3-hour summit about FDW sharding\nat the PG-EU conference in Vienna. Everyone is invited, but it is hoped\nmost of the September 1 folks can attend. \nFebruary, 2016: Oleg is planning a similar meeting at their February\nMoscow conference. \nAnyway, I wanted to explain the work that has been happening around\nsharding.Thanks As things move forward, I am increasingly convinced that write\nscaling will be needed soon,+1 that the XC approach is the only reasonable way to do it, and that FDWs are the cleanest way to get it into community\nPostgres.Those two things aren't at all obvious to me.Please don't presume my opposition. If the technical information were made public, I might understand and agree with \"the FDW approach\", perhaps others also. 2ndQuadrant is certainly happy to become involved in any team aiming to add features to Postgres core, as long as that makes sense. There may be areas we can all agree upon even if the full architecture remains in doubt.Before the community commits to a long term venture together we should see the plan. Like all IT projects, expensive failure is possible and the lack of a design is a huge flashing red warning light for me at present. If that requires a meeting of all Developers, why are the meetings for this specifically not happening at the agreed Developer meetings?At PGCon we agreed to have such meeting in Vienna at least. But I think we should be prepared and try to clean all our issues before. It looks like we already out of time,but probably we could meet in Hong Kong ? Honestly, I still don't know which approach is better, we already played with XL (ported to 9.4) and identified some very strong issues with inconsistency, which scared us, especially taking into account how easy we found them. XC people have fixed them, but I'm not sure if they were fundamental and if we could construct more sophisticated tests and find more issues in XC/XL. We also a bit disappointed by Huawei position about CSN patch, we hoped to use for our XTM. FDW approach has been actively criticized by pg_shard people and that's also made me a bit suspicious. It looks like we are doomed to continue several development forks, so we decided to work on very important common project, XTM, which we hoped could be accepted by all parties and eventually committed to 9.6. Now I see we were right, unfortunately. Again, could we organize meeting somewhere in September ? US is not good for us, but other places should be ok. I want to have an agreement at least on XTM. We still are testing various approaches, though. We could present results of our experiments and are open to discussion. It's not easy project, but it's something we could do for 9.6.I'm very glad Bruce started this discussion in -hackers, since it's silly to me to participate in both threads :) Let's meet in September ! -- Simon Riggs http://www.2ndQuadrant.com/PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services","msg_date":"Sun, 30 Aug 2015 22:36:23 +0300","msg_from":"Oleg Bartunov <obartunov@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Sun, Aug 30, 2015 at 03:31:10PM +0100, Simon Riggs wrote:\n> On 30 August 2015 at 03:17, Bruce Momjian <bruce@momjian.us> wrote:\n> \n> I have recently increased my public statements about the idea of adding\n> horizontal scaling/sharding to Postgres.\n>\n> Glad to see it. Many people have been pushing such things for years, so it is\n> good to finally see some debate about this on Hackers.\n\nAgreed. Right now, in our community, we are only seeing users who are\nhappy with what Postgres offers but think they might need massive\nhorizontal scalability in the future. I think there is a larger group\nthat cares about massive horizontal scalability, but those people are\nusing other software right now, so we don't see them yet.\n\nWithout a roadmap for built-in massive horizontal scalability, I think\nPostgres adoption will eventually suffer.\n\n> I wanted to share with hackers\n> a timeline of how we got here, and where I think we are going in the\n> short term:\n> \n> 2012-2013:� As part of writing my scaling talk\n> (http://momjian.us/main/presentations/overview.html#scaling), studying\n> Oracle RAC, and talking to users, it became clear that an XC-like\n> architecture (sharding) was the only architecture that was going to allow\n> for write scaling.\n> \n> \n> What other architectures were discussed? Where was that discussion?\n\nThat was mostly my conclusion. I explained it to small groups at\nconferences and Postgres user groups. No one said I was wrong, but that\nis about the level of debate I had.\n\n> 2014:� I started to shop around the idea that we could use FDWs,\n> parallelism, and a transaction/snapshot manager to get XC features\n> as built-in to Postgres.� (I don't remember where the original idea\n> came from.)� It was clear that having separate forks of the source code\n> in XC and XL was never going to achieve critical mass --- there just\n> aren't enough people who need high right scale right now, and the fork\n> maintenance overhead is a huge burden.\n> \n> \n> I personally support the view that we should put scalability features into\n> Postgres core, rather than run separate forks.\n\nGood, I do think it is time, but as I stated above, there is limited\ninterest in our current community, so the tolerance for additional\ncommunity code to accomplish this is also limited. This is the big\nthing that had me excited about using FDWs --- FDW improvements can get\nus closer to sharding without requiring community acceptance of\nsharding-only features.\n\n> I realized that we would never get community acceptance to dump the XC\n> (or XL) code needed for sharding into community Postgres\n> \n> \n> How or why did you realize that? There has never been any such discussion,\n> AFAIK. Surely it can be possible to move required subsystems across?\n\nWell, I have had many such discussions with XC/XL folks, and that was my\nopinion. I have seen almost no public discussion about this because the\nidea had almost no chance of success. If it was possible, someone would\nhave already suggested it on this list.\n\n> , but with FDWs,\n> we could add the features as _part_ of improving FDWs, which would benefit\n> FDWs _and_ would be useful for sharding.� (We already see some of those\n> FDW features in 9.5.)\n> \n> \n> That is a huge presumption. Not discussed or technically analyzed in any way\n> with the community.\n\nTrue. It seemed pretty obvious to me.\n\n> October, 2014:� EDB and NTT started working together in the community\n> to start improving FDWs as a basis for an FDW-based sharding solution.\n> Many of the 9.5 FDW improvements that also benefit sharding were developed\n> by a combined EDB/NTT team.� The features improved FDWs independent of\n> sharding, so they didn't need community buy-in on sharding to get them\n> accepted.\n> \n> June, 2015:� I attended the PGCon sharding unconference session and\n> there was a huge discussion about where we should go with sharding.\n> I think the big take-away was that most people liked the FDW approach,\n> but had business/customer reasons for wanting to work on XC or XL because\n> those would be production-ready faster.\n> \n> \n> Cough, cough. You must surely be joking that \"most people liked the FDW\n> approach\"? How did we measure the acceptance of this approach?�\n\nWell, I didn't have my audience-meter with me at the time. ;-)\n\nThe discussion was mostly in the hallway after the unconference session,\n\"Future of PostgreSQL shared-nothing cluster\" by Konstantin Knizhnik,\nAlexander Korotkov, and Oleg Bartunov. Again, when I explained the\nability to use FDWs to get sharding into Postgres with minimal\nadditional code, no one said the idea was crazy, which I took as a big\nthumbs-up! When I asked why to continue with XC/XL, I was told those\nwere more mature and more customer-ready, which is true. I will not\nquote people from the from the hallway discussion for privacy reasons.\n\n> What actually is the FDW approach? Since its not been written down anywhere, or\n> even explained verbally, how can anyone actually agree to it?\n\nWell, my sharding talk just has the outlines of an approach. I think\nthere are five broad segments:\n\n* FDW push-down of joins, sorts, aggregates\n* ability to send FDW requests in parallel\n* transaction/snapshot manager to allow ACID transctions on shards\n* simpler user partitioning API\n* infrastructure to manage shards, including replicated tables used for joins\n\n> July, 2015:� Oleg Bartunov and his new company Postgres Professional (PP)\n> started to think about joining the FDW approach, rather than working on\n> XL, as they had stated at PGCon in June.� A joint NTT/EDB/PP phone-in\n> meeting is scheduled for September 1.\n>\n> August, 2015:� While speaking at SFPUG, Citus Data approached me about\n> joining the FDW sharding team.� They have been invited to the September\n> 1 meeting, as have the XC and XL people.\n> \n> \n> 2ndQuadrant is working in this area, specifically bringing XL 9.5 forwards.\n\nYes, I saw the blog post about that:\n\n\thttp://blog.2ndquadrant.com/working-towards-postgres-xl-9-5/\n\n> Please can invites be posted to myself, Pavan Deolasee and Petr Jelinek also?\n> I'll pass on to others also.\n\nOK, I will send you a separate email and you can then supply their email\naddresses.\n\n> Koichi Suzuki is arranging a meeting in Hong Long for XC/XL discussions.\n> Presumably EDB is invited also? If Koichi is a leading organizer of this, why\n> are there two meetings?\n\nI certainly have heard nothing about it, except third-hand people\ntelling me a meeting is happening. I assumed those meetings where\nXC/XL-specific.\n\n> that the XC approach is the only reasonable�way to do it,\n> and that FDWs are the cleanest way to get it into community\n> Postgres.\n> \n> Those two things aren't at all obvious to me.\n>\n> Please don't presume my opposition. If the technical information were made\n> public, I might understand and agree with \"the FDW approach\", perhaps others\n> also.\n\nWell, the beauty of my approach is that we didn't need any technical\ndirection or buy-in on sharding from the community to improve FDWs. I\nthink now is the right time to try to get that buy-in, or adjust our\napproach.\n\nThere isn't really much more to my _analysis_ than I presented. There\nis certainly a lot more work to do to even decide this is the right\napproach. Some of the groups already involved have more experience in\ntrying this, e.g. Citus Data.\n\n> 2ndQuadrant is certainly happy to become involved in any team aiming to\n> add features to Postgres core, as long as that makes sense. There may be areas\n> we can all agree upon even if the full architecture remains in doubt.\n\nRight.\n\n> Before the community commits to a long term venture together we should see the\n> plan. Like all IT projects, expensive failure is possible and the lack of a\n> design is a huge flashing red warning light for me at present. If that requires\n> a meeting of all Developers, why are the meetings for this specifically not\n> happening at the agreed Developer meetings?\n\nWell, what meetings should it be at? I don't think there was clear\nenough direction for the June 2015 PGCon meeting. Is there an\nunconference in Vienna? One thing I saw at the last PGCon is that this\nis a big topic, so I think having a dedicated room and 3-hour slot for\nit is nice.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 30 Aug 2015 18:29:43 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Sun, Aug 30, 2015 at 10:36:23PM +0300, Oleg Bartunov wrote:\n> Honestly, I still don't know which approach is better, we already played with\n> XL (ported to 9.4)� and identified some very strong issues with inconsistency,\n> which scared us, especially taking into account how easy we found them. XC\n> people have fixed them, but I'm not sure if they were fundamental and if we\n> could construct more sophisticated tests and find more issues in XC/XL. We also\n> a bit disappointed by Huawei position about CSN patch, we hoped to use for� our\n> XTM.� FDW approach has been actively criticized by pg_shard people and that's\n> also made me a bit suspicious.�\n\nYep, that has me concerned too. The pg_shard people will be on the\nSeptember 1 call and are working on a Google document to explain their\nconcerns about FDWs for sharding.\n\n> It looks like� we are doomed to continue\n> several development forks, so we decided to work on very important common\n> project, XTM, which we hoped could be accepted by all parties and eventually\n> committed to 9.6.� Now I see we were right, unfortunately.��\n\nYes, the ability to add independent parts that can eventually be used\nfor sharding is a strong indication that doing this incrementally is a\ngood approach.\n\n> Again, could we organize meeting somewhere in September ?� US is not good for\n> us, but other places should be ok. I want to have an agreement� at least on\n> XTM. We still are testing various approaches, though. We could present results\n> of our experiments and are open to discussion. It's not easy project, but it's\n> something we could do for 9.6.\n\nGood. XTM is a must-have for several use-cases, including sharding.\n\n> I'm very glad Bruce started this discussion in -hackers, since it's silly to me\n> to participate in both threads :)� Let's meet in September !\n\nIn summary, I think we need to start working on built-in sharding, and\nFDWs are the only way I can see to do it with minimal code changes,\nwhich I think might be a community requirement. It might not work, but\nright now, it is the only possible approach I can see.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 30 Aug 2015 19:04:16 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Mon, Aug 31, 2015 at 7:29 AM, Bruce Momjian <bruce@momjian.us> wrote:\n\n> On Sun, Aug 30, 2015 at 03:31:10PM +0100, Simon Riggs wrote:\n> > I realized that we would never get community acceptance to dump the\n> XC\n> > (or XL) code needed for sharding into community Postgres\n> >\n> >\n> > How or why did you realize that? There has never been any such\n> discussion,\n> > AFAIK. Surely it can be possible to move required subsystems across?\n>\n> Well, I have had many such discussions with XC/XL folks, and that was my\n> opinion. I have seen almost no public discussion about this because the\n> idea had almost no chance of success. If it was possible, someone would\n> have already suggested it on this list.\n>\n\nOr perhaps people invested in this area had other obligations or lacked\nmotivation and/or time to work to push up for things in core. That's not\npossible to know, and what is done is done.\n\n\n> > July, 2015: Oleg Bartunov and his new company Postgres Professional\n> (PP)\n> > started to think about joining the FDW approach, rather than working\n> on\n> > XL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\n> > meeting is scheduled for September 1.\n> >\n> > August, 2015: While speaking at SFPUG, Citus Data approached me\n> about\n> > joining the FDW sharding team. They have been invited to the\n> September\n> > 1 meeting, as have the XC and XL people.\n> >\n> >\n> > 2ndQuadrant is working in this area, specifically bringing XL 9.5\n> forwards.\n>\n> Yes, I saw the blog post about that:\n>\n> http://blog.2ndquadrant.com/working-towards-postgres-xl-9-5/\n>\n> > Please can invites be posted to myself, Pavan Deolasee and Petr Jelinek\n> also?\n> > I'll pass on to others also.\n>\n> OK, I will send you a separate email and you can then supply their email\n> addresses.\n>\n\nFWIW, I would be interested in that as well. I worked in this area of\nthings for a couple of years as well FWIW.\n\n\n> > Koichi Suzuki is arranging a meeting in Hong Long for XC/XL discussions.\n> > Presumably EDB is invited also? If Koichi is a leading organizer of\n> this, why\n> > are there two meetings?\n>\n> I certainly have heard nothing about it, except third-hand people\n> telling me a meeting is happening. I assumed those meetings where\n> XC/XL-specific.\n>\n\nYep, that's my understanding as well and AFAIK as I know things have been\ncarried this way until now, aka XC/XL and Postgres core are aimed to live\nas separate communities.\n-- \nMichael\n\nOn Mon, Aug 31, 2015 at 7:29 AM, Bruce Momjian <bruce@momjian.us> wrote:On Sun, Aug 30, 2015 at 03:31:10PM +0100, Simon Riggs wrote:\n> I realized that we would never get community acceptance to dump the XC\n> (or XL) code needed for sharding into community Postgres\n>\n>\n> How or why did you realize that? There has never been any such discussion,\n> AFAIK. Surely it can be possible to move required subsystems across?\n\nWell, I have had many such discussions with XC/XL folks, and that was my\nopinion. I have seen almost no public discussion about this because the\nidea had almost no chance of success. If it was possible, someone would\nhave already suggested it on this list.Or perhaps people invested in this area had other obligations or lacked motivation and/or time to work to push up for things in core. That's not possible to know, and what is done is done. \n> July, 2015: Oleg Bartunov and his new company Postgres Professional (PP)\n> started to think about joining the FDW approach, rather than working on\n> XL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\n> meeting is scheduled for September 1.\n>\n> August, 2015: While speaking at SFPUG, Citus Data approached me about\n> joining the FDW sharding team. They have been invited to the September\n> 1 meeting, as have the XC and XL people.\n>\n>\n> 2ndQuadrant is working in this area, specifically bringing XL 9.5 forwards.\n\nYes, I saw the blog post about that:\n\n http://blog.2ndquadrant.com/working-towards-postgres-xl-9-5/\n\n> Please can invites be posted to myself, Pavan Deolasee and Petr Jelinek also?\n> I'll pass on to others also.\n\nOK, I will send you a separate email and you can then supply their email\naddresses.FWIW, I would be interested in that as well. I worked in this area of things for a couple of years as well FWIW. \n> Koichi Suzuki is arranging a meeting in Hong Long for XC/XL discussions.\n> Presumably EDB is invited also? If Koichi is a leading organizer of this, why\n> are there two meetings?\n\nI certainly have heard nothing about it, except third-hand people\ntelling me a meeting is happening. I assumed those meetings where\nXC/XL-specific.Yep, that's my understanding as well and AFAIK as I know things have been carried this way until now, aka XC/XL and Postgres core are aimed to live as separate communities.-- Michael","msg_date":"Mon, 31 Aug 2015 09:53:57 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Mon, Aug 31, 2015 at 09:53:57AM +0900, Michael Paquier wrote:\n> Well, I have had many such discussions with XC/XL folks, and that was my\n> opinion.� I have seen almost no public discussion about this because the\n> idea had almost no chance of success.� If it was possible, someone would\n> have already suggested it on this list.\n> \n> \n> Or perhaps people invested in this area had other obligations or lacked\n> motivation and/or time to work to push up for things in core. That's not\n> possible to know, and what is done is done.\n\nWell, I have talked to everyone privately about this, and concluded that\nwhile horizontal scalability/sharding is useful, it is unlikely that the\ncode volume of something like XC or XL would be accepted into the\ncommunity, and frankly, now that we have FDWs, it is hard to imagine why\nwe would _not_ go in the FDW direction. \n\nOf course, people have concerns, and FDWs might need to be improved, but\nit is something worth researching. We might find out FDWs can't be used\nat all, and that we have to either add much more code to Postgres to do\nsharding, do something like pg_shard, or not implement built-in sharding\nat all, but at least it is time to research this.\n\n> OK, I will send you a separate email and you can then supply their email\n> addresses.\n> \n> \n> FWIW, I would be interested in that as well. I worked in this area of things\n> for a couple of years as well FWIW.\n\nOK, I will send you an email.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 30 Aug 2015 22:08:06 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Sun, Aug 30, 2015 at 10:08:06PM -0400, Bruce Momjian wrote:\n> On Mon, Aug 31, 2015 at 09:53:57AM +0900, Michael Paquier wrote:\n> > Well, I have had many such discussions with XC/XL folks, and that was my\n> > opinion.� I have seen almost no public discussion about this because the\n> > idea had almost no chance of success.� If it was possible, someone would\n> > have already suggested it on this list.\n> > \n> > \n> > Or perhaps people invested in this area had other obligations or lacked\n> > motivation and/or time to work to push up for things in core. That's not\n> > possible to know, and what is done is done.\n> \n> Well, I have talked to everyone privately about this, and concluded that\n> while horizontal scalability/sharding is useful, it is unlikely that the\n> code volume of something like XC or XL would be accepted into the\n> community, and frankly, now that we have FDWs, it is hard to imagine why\n> we would _not_ go in the FDW direction. \n\nActually, there was hope that XC or XL would get popular enough that it\nwould justify adding their code into community Postgres, but that never\nhappened.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 30 Aug 2015 22:48:31 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Mon, Aug 31, 2015 at 11:08 AM, Bruce Momjian <bruce@momjian.us> wrote:\n>\n> On Mon, Aug 31, 2015 at 09:53:57AM +0900, Michael Paquier wrote:\n> > Well, I have had many such discussions with XC/XL folks, and that was my\n> > opinion. I have seen almost no public discussion about this because the\n> > idea had almost no chance of success. If it was possible, someone would\n> > have already suggested it on this list.\n> >\n> >\n> > Or perhaps people invested in this area had other obligations or lacked\n> > motivation and/or time to work to push up for things in core. That's not\n> > possible to know, and what is done is done.\n>\n> Well, I have talked to everyone privately about this, and concluded that\n> while horizontal scalability/sharding is useful, it is unlikely that the\n> code volume of something like XC or XL would be accepted into the\n> community, and frankly, now that we have FDWs, it is hard to imagine why\n> we would _not_ go in the FDW direction.\n\nIf I recall correctly in terms of numbers, that's indeed 40k of code,\nthe main areas of XC code being the GTM, the planner changes for\nexpression and join push down, and the connection pooler for parallel\nquery execution.\n\nISTM that FDW is a portion of the puzzle, there are other pieces that\ncould be used toward an in-core integration, like the parallel stuff\nAmit Kapila is working on to allow remote query execution in parallel\nof local scans. Also, XC/XL were performing well on OLTP thanks to the\nconnection pooler: this should indeed be part of the FDW portion\nmanaging the foreign scans. This may sound like a minor issue compared\nto the others, but already established connections help a lot when\nscaling out with foreign servers.\n\n> Of course, people have concerns, and FDWs might need to be improved, but\n> it is something worth researching. We might find out FDWs can't be used\n> at all, and that we have to either add much more code to Postgres to do\n> sharding, do something like pg_shard, or not implement built-in sharding\n> at all, but at least it is time to research this.\n\nI am really looking forward to hearing the arguments of the authors of\npg_shard on the matter.\n\n> > OK, I will send you a separate email and you can then supply their email\n> > addresses.\n> >\n> >\n> > FWIW, I would be interested in that as well. I worked in this area of things\n> > for a couple of years as well FWIW.\n>\n> OK, I will send you an email.\n\nThanks.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 31 Aug 2015 12:03:37 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Mon, Aug 31, 2015 at 11:48 AM, Bruce Momjian <bruce@momjian.us> wrote:\n> On Sun, Aug 30, 2015 at 10:08:06PM -0400, Bruce Momjian wrote:\n>> On Mon, Aug 31, 2015 at 09:53:57AM +0900, Michael Paquier wrote:\n>> > Well, I have had many such discussions with XC/XL folks, and that was my\n>> > opinion. I have seen almost no public discussion about this because the\n>> > idea had almost no chance of success. If it was possible, someone would\n>> > have already suggested it on this list.\n>> >\n>> >\n>> > Or perhaps people invested in this area had other obligations or lacked\n>> > motivation and/or time to work to push up for things in core. That's not\n>> > possible to know, and what is done is done.\n>>\n>> Well, I have talked to everyone privately about this, and concluded that\n>> while horizontal scalability/sharding is useful, it is unlikely that the\n>> code volume of something like XC or XL would be accepted into the\n>> community, and frankly, now that we have FDWs, it is hard to imagine why\n>> we would _not_ go in the FDW direction.\n>\n> Actually, there was hope that XC or XL would get popular enough that it\n> would justify adding their code into community Postgres, but that never\n> happened.\n\nForks are aimed to die without proper maintenance resources. Still,\nfor XC/XL, what does not help is the complication of the architecture\nand SPOF management, particularly thinking with the GTM that was\nsomething completely new and not well understood (there is a GTM\nstandby but this model is weak IMO and does not scale similarly to\nwhat you get with standbys, and impacts the overall performance of the\ncluster).\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 31 Aug 2015 12:06:53 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Sun, Aug 30, 2015 at 7:47 AM, Bruce Momjian <bruce@momjian.us> wrote:\n>\n> I have recently increased my public statements about the idea of adding\n> horizontal scaling/sharding to Postgres. I wanted to share with hackers\n> a timeline of how we got here, and where I think we are going in the\n> short term:\n>\n> 2012-2013: As part of writing my scaling talk\n> (http://momjian.us/main/presentations/overview.html#scaling), studying\n> Oracle RAC, and talking to users, it became clear that an XC-like\n> architecture (sharding) was the only architecture that was going to allow\n> for write scaling.\n>\n\nI think sharding like architecture is quite useful for certain kind of\nworkloads\nwhere users can manage to arrange queries and data layout in an optimized\nway which I hope users might agree to change if required. One thing to\nconsider here is what kind of scaling are we expecting in such a system and\nis it sufficient considering we will keep focussed on this architecture for\nhorizontal scalability?\nGenerally speaking, the scaling in such systems is limited by the number of\nprofitable partitions user can create based on data and then cross-partition\ntransactions sucks the performance/scalability in such systems. I\nunderstand that there is definitely a benefit in proceeding with sharding\nlike\narchitecture as there are already some PostgreSQL based forks which uses\nsuch architecture, so if we follow same way, we can save some effort rather\nthan inventing or following some other architecture, however there is no\nharm\nis discussing pros and cons of some other architectures like Oracle RAC,\nGoogle F1 or others.\n\n\nWith Regards,\nAmit Kapila.\nEnterpriseDB: http://www.enterprisedb.com\n\nOn Sun, Aug 30, 2015 at 7:47 AM, Bruce Momjian <bruce@momjian.us> wrote:>> I have recently increased my public statements about the idea of adding> horizontal scaling/sharding to Postgres. I wanted to share with hackers> a timeline of how we got here, and where I think we are going in the> short term:>> 2012-2013: As part of writing my scaling talk> (http://momjian.us/main/presentations/overview.html#scaling), studying> Oracle RAC, and talking to users, it became clear that an XC-like> architecture (sharding) was the only architecture that was going to allow> for write scaling.>I think sharding like architecture is quite useful for certain kind of workloadswhere users can manage to arrange queries and data layout in an optimizedway which I hope users might agree to change if required. One thing toconsider here is what kind of scaling are we expecting in such a system andis it sufficient considering we will keep focussed on this architecture forhorizontal scalability?Generally speaking, the scaling in such systems is limited by the number ofprofitable partitions user can create based on data and then cross-partitiontransactions sucks the performance/scalability in such systems. Iunderstand that there is definitely a benefit in proceeding with sharding likearchitecture as there are already some PostgreSQL based forks which usessuch architecture, so if we follow same way, we can save some effort ratherthan inventing or following some other architecture, however there is no harmis discussing pros and cons of some other architectures like Oracle RAC,Google F1 or others.With Regards,Amit Kapila.EnterpriseDB: http://www.enterprisedb.com","msg_date":"Mon, 31 Aug 2015 10:18:25 +0530","msg_from":"Amit Kapila <amit.kapila16@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":">\n>\n> At PGCon we agreed to have such meeting in Vienna at least. But I think we\n> should be prepared and try to clean all our issues before. It looks like we\n> already out of time,but probably we could meet in Hong Kong ?\n>\n> Honestly, I still don't know which approach is better, we already played\n> with XL (ported to 9.4) and identified some very strong issues with\n> inconsistency, which scared us, especially taking into account how easy we\n> found them. XC people have fixed them, but I'm not sure if they were\n> fundamental and if we could construct more sophisticated tests and find\n> more issues in XC/XL. We also a bit disappointed by Huawei position about\n> CSN patch, we hoped to use for our XTM. FDW approach has been actively\n> criticized by pg_shard people and that's also made me a bit suspicious. It\n> looks like we are doomed to continue several development forks, so we\n> decided to work on very important common project, XTM, which we hoped could\n> be accepted by all parties and eventually committed to 9.6. Now I see we\n> were right, unfortunately.\n>\n\nDistributed transaction manager should support at least three things\n1. Atomic commit\n2. Atomic visibility\n3. Consistent snapshots (e.g. required for repeatable reads and higher\nisolation levels).\n\nI have submitted patch for implementing first for FDWs. The patch adds\ninfrastructure to be used by all FDWs including postgres_fdw. It also adds\npostgres_fdw code to use this infrastructure. The same can be used to\nachieve atomic commit in postgres_fdw based sharding. Please see if XTM can\nbenefit from it. If there are things that are required by XTM, please post\nthe requirements on that thread and I will work on those. You can find the\nlatest patch at\nhttp://www.postgresql.org/message-id/CAFjFpRfANWL53+x2HdM9TCNe5pup=oPkQSSJ-KGfr-d2efj+CQ@mail.gmail.com\n\n\n>\n> Again, could we organize meeting somewhere in September ? US is not good\n> for us, but other places should be ok. I want to have an agreement at\n> least on XTM. We still are testing various approaches, though. We could\n> present results of our experiments and are open to discussion. It's not\n> easy project, but it's something we could do for 9.6.\n>\n> I'm very glad Bruce started this discussion in -hackers, since it's silly\n> to me to participate in both threads :) Let's meet in September !\n>\n>\n>\n>> --\n>> Simon Riggs http://www.2ndQuadrant.com/\n>> <http://www.2ndquadrant.com/>\n>> PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n>>\n>\n>\n\n\n-- \nBest Wishes,\nAshutosh Bapat\nEnterpriseDB Corporation\nThe Postgres Database Company\n\nAt PGCon we agreed to have such meeting in Vienna at least. But I think we should be prepared and try to clean all our issues before. It looks like we already out of time,but probably we could meet in Hong Kong ? Honestly, I still don't know which approach is better, we already played with XL (ported to 9.4) and identified some very strong issues with inconsistency, which scared us, especially taking into account how easy we found them. XC people have fixed them, but I'm not sure if they were fundamental and if we could construct more sophisticated tests and find more issues in XC/XL. We also a bit disappointed by Huawei position about CSN patch, we hoped to use for our XTM. FDW approach has been actively criticized by pg_shard people and that's also made me a bit suspicious. It looks like we are doomed to continue several development forks, so we decided to work on very important common project, XTM, which we hoped could be accepted by all parties and eventually committed to 9.6. Now I see we were right, unfortunately.Distributed transaction manager should support at least three things1. Atomic commit2. Atomic visibility3. Consistent snapshots (e.g. required for repeatable reads and higher isolation levels).I have submitted patch for implementing first for FDWs. The patch adds infrastructure to be used by all FDWs including postgres_fdw. It also adds postgres_fdw code to use this infrastructure. The same can be used to achieve atomic commit in postgres_fdw based sharding. Please see if XTM can benefit from it. If there are things that are required by XTM, please post the requirements on that thread and I will work on those. You can find the latest patch at http://www.postgresql.org/message-id/CAFjFpRfANWL53+x2HdM9TCNe5pup=oPkQSSJ-KGfr-d2efj+CQ@mail.gmail.com Again, could we organize meeting somewhere in September ? US is not good for us, but other places should be ok. I want to have an agreement at least on XTM. We still are testing various approaches, though. We could present results of our experiments and are open to discussion. It's not easy project, but it's something we could do for 9.6.I'm very glad Bruce started this discussion in -hackers, since it's silly to me to participate in both threads :) Let's meet in September ! -- Simon Riggs http://www.2ndQuadrant.com/PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- Best Wishes,Ashutosh BapatEnterpriseDB CorporationThe Postgres Database Company","msg_date":"Mon, 31 Aug 2015 10:52:28 +0530","msg_from":"Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Mon, Aug 31, 2015 at 5:48 AM, Bruce Momjian <bruce@momjian.us> wrote:\n\n> On Sun, Aug 30, 2015 at 10:08:06PM -0400, Bruce Momjian wrote:\n> > On Mon, Aug 31, 2015 at 09:53:57AM +0900, Michael Paquier wrote:\n> > > Well, I have had many such discussions with XC/XL folks, and that\n> was my\n> > > opinion. I have seen almost no public discussion about this\n> because the\n> > > idea had almost no chance of success. If it was possible, someone\n> would\n> > > have already suggested it on this list.\n> > >\n> > >\n> > > Or perhaps people invested in this area had other obligations or lacked\n> > > motivation and/or time to work to push up for things in core. That's\n> not\n> > > possible to know, and what is done is done.\n> >\n> > Well, I have talked to everyone privately about this, and concluded that\n> > while horizontal scalability/sharding is useful, it is unlikely that the\n> > code volume of something like XC or XL would be accepted into the\n> > community, and frankly, now that we have FDWs, it is hard to imagine why\n> > we would _not_ go in the FDW direction.\n>\n> Actually, there was hope that XC or XL would get popular enough that it\n> would justify adding their code into community Postgres, but that never\n> happened.\n>\n\nAFAIK, XC/XL has already some customers and that is an additional pressure\non their development team, which is now called X2. I don't exactly know how\ninternal Huawei's MPPDB is connected to XC/XL.\n\nWe need community test suite for cluster and our company is working on\nthis. It's non-trivial work, but community will never accepts any cluster\nsolution without thorough testing of functionality and performance. Our\nXC/XL experience was not good.\n\n\n\n>\n> --\n> Bruce Momjian <bruce@momjian.us> http://momjian.us\n> EnterpriseDB http://enterprisedb.com\n>\n> + Everyone has their own god. +\n>\n>\n> --\n> Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\n> To make changes to your subscription:\n> http://www.postgresql.org/mailpref/pgsql-hackers\n>\n\nOn Mon, Aug 31, 2015 at 5:48 AM, Bruce Momjian <bruce@momjian.us> wrote:On Sun, Aug 30, 2015 at 10:08:06PM -0400, Bruce Momjian wrote:\n> On Mon, Aug 31, 2015 at 09:53:57AM +0900, Michael Paquier wrote:\n> > Well, I have had many such discussions with XC/XL folks, and that was my\n> > opinion. I have seen almost no public discussion about this because the\n> > idea had almost no chance of success. If it was possible, someone would\n> > have already suggested it on this list.\n> >\n> >\n> > Or perhaps people invested in this area had other obligations or lacked\n> > motivation and/or time to work to push up for things in core. That's not\n> > possible to know, and what is done is done.\n>\n> Well, I have talked to everyone privately about this, and concluded that\n> while horizontal scalability/sharding is useful, it is unlikely that the\n> code volume of something like XC or XL would be accepted into the\n> community, and frankly, now that we have FDWs, it is hard to imagine why\n> we would _not_ go in the FDW direction.\n\nActually, there was hope that XC or XL would get popular enough that it\nwould justify adding their code into community Postgres, but that never\nhappened.AFAIK, XC/XL has already some customers and that is an additional pressure on their development team, which is now called X2. I don't exactly know how internal Huawei's MPPDB is connected to XC/XL. We need community test suite for cluster and our company is working on this. It's non-trivial work, but community will never accepts any cluster solution without thorough testing of functionality and performance. Our XC/XL experience was not good. \n\n--\n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n--\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers","msg_date":"Mon, 31 Aug 2015 12:12:02 +0300","msg_from":"Oleg Bartunov <obartunov@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":">\n>\n> We also a bit disappointed by Huawei position about CSN patch, we hoped\n> to use for our XTM.\n>\n\nDisappointed in what way? Moving to some sort of CSN approach seems to open\nthings up for different future ideas. In the short term, it would mean\nreplacing potentially large snapshots and longer visibility checks. In the\nlong term, perhaps CSN could help simplify the design of multi-master\nreplication schemes.\n\n\n> FDW approach has been actively criticized by pg_shard people and that's\n> also made me a bit suspicious. It looks like we are doomed to continue\n> several development forks, so we decided to work on very important common\n> project, XTM, which we hoped could be accepted by all parties and\n> eventually committed to 9.6. Now I see we were right, unfortunately.\n>\n>\nI think the original XC project probably would have taken the FDW approach\nas a basis if it had existed, with focus on push-down optimizations.\n\nI assume that future work around PG sharding probably would be more likely\nto be accepted with the FDW approach. One could perhaps work on pushing\ndown joins, aggregates and order by, then look at any optimizations gained\nif code is moved outside of FDW. It would make sense if some kind of\ngeneric optimization for foreign tables for SQL-based sources could be\nleveraged across all databases, rather than having to re-implement for each\nFDW.\n\nThere are different approaches and related features that may need to be\nimproved.\n\nDo we want multiple copies of shards, like the pg_shard approach? Or keep\nthings simpler and leave it up to the DBA to add standbys?\n\nDo we want to leverage table inheritance? If so, we may want to spend time\nimproving performance for when the number of shards becomes large with what\ncurrently exists. If using table inheritance, we could add the ability to\nspecify what node (er, foreign server) the subtable lives on. We could\ncreate top level sharding expressions that allow these to be implicitly\ncreated.\n\nShould we allow arbitrary expressions for shards, not just range, list and\nhash?\n\nMaybe the most community-acceptable approach would look something like\n\n- Use FDWs, and continue to optimize push-down operations, also for\nnon-PostgreSQL databases.\n\n- Use table inheritance for defining the shards. Ideally allow for\nspecifying that some shards may be replicated to other foreign servers (and\nitself) (for pushing down joins with lookup/static tables; at this point it\nshould be decent for star schema based data warehouses).\n\n- XTM/GTM hooks. Preferably we move to CSN for snapshots in core PostgreSQL\nthough.\n\nLonger term, efficient internode joins would require a lot more work.\n\nThe devil is in the details. There are things that have to be addressed,\nfor example, if using global XIDs via GTM, not every transaction is on\nevery node, so we need to make sure that new clog pages get added\nproperly. There is also the potential to require a lot more code to be\nadded, like for cursor handling and stored functions. Perhaps some\nlimitations when using shards to foreign servers are acceptable if it is\ndesired to minimize code changes. XC and XL code help.\n\nRegards,\n\nMason\n\n We also a bit disappointed by Huawei position about CSN patch, we hoped to use for our XTM. Disappointed in what way? Moving to some sort of CSN approach seems to open things up for different future ideas. In the short term, it would mean replacing potentially large snapshots and longer visibility checks. In the long term, perhaps CSN could help simplify the design of multi-master replication schemes. FDW approach has been actively criticized by pg_shard people and that's also made me a bit suspicious. It looks like we are doomed to continue several development forks, so we decided to work on very important common project, XTM, which we hoped could be accepted by all parties and eventually committed to 9.6. Now I see we were right, unfortunately. I think the original XC project probably would have taken the FDW approach as a basis if it had existed, with focus on push-down optimizations. I assume that future work around PG sharding probably would be more likely to be accepted with the FDW approach. One could perhaps work on pushing down joins, aggregates and order by, then look at any optimizations gained if code is moved outside of FDW. It would make sense if some kind of generic optimization for foreign tables for SQL-based sources could be leveraged across all databases, rather than having to re-implement for each FDW.There are different approaches and related features that may need to be improved.Do we want multiple copies of shards, like the pg_shard approach? Or keep things simpler and leave it up to the DBA to add standbys? Do we want to leverage table inheritance? If so, we may want to spend time improving performance for when the number of shards becomes large with what currently exists. If using table inheritance, we could add the ability to specify what node (er, foreign server) the subtable lives on. We could create top level sharding expressions that allow these to be implicitly created.Should we allow arbitrary expressions for shards, not just range, list and hash?Maybe the most community-acceptable approach would look something like- Use FDWs, and continue to optimize push-down operations, also for non-PostgreSQL databases.- Use table inheritance for defining the shards. Ideally allow for specifying that some shards may be replicated to other foreign servers (and itself) (for pushing down joins with lookup/static tables; at this point it should be decent for star schema based data warehouses). - XTM/GTM hooks. Preferably we move to CSN for snapshots in core PostgreSQL though.Longer term, efficient internode joins would require a lot more work.The devil is in the details. There are things that have to be addressed, for example, if using global XIDs via GTM, not every transaction is on every node, so we need to make sure that new clog pages get added properly. There is also the potential to require a lot more code to be added, like for cursor handling and stored functions. Perhaps some limitations when using shards to foreign servers are acceptable if it is desired to minimize code changes. XC and XL code help.Regards,Mason","msg_date":"Mon, 31 Aug 2015 14:48:31 -0400","msg_from":"Mason S <masonlists@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Mon, Aug 31, 2015 at 02:48:31PM -0400, Mason S wrote:\n> I assume that future work around PG sharding probably would be more likely to\n> be accepted with the FDW approach. One could perhaps work on pushing down\n> joins, aggregates and order by, then look at any optimizations gained if code\n> is moved outside of FDW.� It would make sense if some kind of generic\n> optimization for foreign tables for SQL-based sources could be leveraged across\n> all databases, rather than having to re-implement for each FDW.\n> \n> There are different approaches and related features that may need to be\n> improved.\n> \n> Do we want multiple copies of shards, like the pg_shard approach? Or keep\n> things simpler and leave it up to the DBA to add standbys?�\n\nI agree with all of the above.\n\n> Do we want to leverage table inheritance? If so, we may want to spend time\n> improving performance for when the number of shards becomes large with what\n> currently exists. If using table inheritance, we could add the ability to\n> specify what node (er, foreign server) the subtable lives on. We could create\n> top level sharding expressions that allow these to be implicitly created.\n> \n> Should we allow arbitrary expressions for shards, not just range, list and\n> hash?\n> \n> Maybe the most community-acceptable approach would look something like\n\nI think everyone agrees that our current partitioning setup is just too\nverbose and error-prone for users, and needs a simpler interface, and\none that can be better optimized internally. I assume FDW-based\nsharding will benefit from that work as well.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 31 Aug 2015 14:59:47 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Mon, Aug 31, 2015 at 9:48 PM, Mason S <masonlists@gmail.com> wrote:\n\n>\n>> We also a bit disappointed by Huawei position about CSN patch, we hoped\n>> to use for our XTM.\n>>\n>\n> Disappointed in what way? Moving to some sort of CSN approach seems to\n> open things up for different future ideas. In the short term, it would mean\n> replacing potentially large snapshots and longer visibility checks. In the\n> long term, perhaps CSN could help simplify the design of multi-master\n> replication schemes.\n>\n\nWe are disappointed because at PGCon talk Huawei announced publishing of\ntheir CSN patch and further work in this direction together with community.\nHowever, it's even not published yet despite all the promises. Nobody from\nHuawei answers CSN thread in the hackers.\nSo, I think we got nothing from Huawei except teasing and should rely only\non ourselves. That is disappointing.\n\n------\nAlexander Korotkov\nPostgres Professional: http://www.postgrespro.com\nThe Russian Postgres Company\n\nOn Mon, Aug 31, 2015 at 9:48 PM, Mason S <masonlists@gmail.com> wrote: We also a bit disappointed by Huawei position about CSN patch, we hoped to use for our XTM. Disappointed in what way? Moving to some sort of CSN approach seems to open things up for different future ideas. In the short term, it would mean replacing potentially large snapshots and longer visibility checks. In the long term, perhaps CSN could help simplify the design of multi-master replication schemes. We are disappointed because at PGCon talk Huawei announced publishing of their CSN patch and further work in this direction together with community. However, it's even not published yet despite all the promises. Nobody from Huawei answers CSN thread in the hackers.So, I think we got nothing from Huawei except teasing and should rely only on ourselves. That is disappointing.------Alexander KorotkovPostgres Professional: http://www.postgrespro.comThe Russian Postgres Company","msg_date":"Mon, 31 Aug 2015 22:08:14 +0300","msg_from":"Alexander Korotkov <a.korotkov@postgrespro.ru>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Mon, Aug 31, 2015 at 2:12 AM, Oleg Bartunov <obartunov@gmail.com> wrote:\n>\n> AFAIK, XC/XL has already some customers and that is an additional pressure\n> on their development team, which is now called X2. I don't exactly know how\n> internal Huawei's MPPDB is connected to XC/XL.\n>\n\nHuawei's MPPDB is based on PG-XC and tailored it more targeting OLAP scenarios.\n\nThe basic idea is that OLAP needs a shared nothing scale out\narchitecture for read and write. It needs ok-TP-performance, a\nrestricted set of functionality, and thus avoids some problems like\nGTM being a central scaling bottleneck.\n\nI advocate to merge PostgreSQL core with scale-out features, if we are\nready to face some long time functional discrepancies between the two\ndeployments.\n\nRegards,\nQingqing\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 31 Aug 2015 12:54:27 -0700","msg_from":"Qingqing Zhou <zhouqq.postgres@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"All, Bruce:\n\nFirst, let me put out there that I think the horizontal scaling project\nwhich has buy-in from the community and we're working on is infinitely\nbetter than the one we're not working on or is an underresourced fork.\nSo we're in agreement on that. However, I think there's a lot of room\nfor discussion; I feel like the FDW approach was decided in exclusive\nmeetings involving a very small number of people. The FDW approach\n*may* be the right approach, but I'd like to see some rigorous\nquestioning of that before it's final.\n\nParticularly, I'm concerned that we already have two projects in process\naimed at horizontal scalability, and it seems like we could bring either\n(or both) projects to production quality MUCH faster than we could make\nan FDW-based solution work. These are:\n\n* pg_shard\n* BDR\n\nIt seems worthwhile, just as a thought experiment, if we can get where\nwe want using those, faster, or by combining those with new FDW features.\n\nIt's also important to recognize that there are three major use-cases\nfor write-scalable clustering:\n\n* OLTP: small-medium cluster, absolute ACID consistency,\n bottlnecked on small writes per second\n* DW: small-large cluster, ACID optional,\n bottlenecked on bulk reads/writes\n* Web: medium to very large cluster, ACID optional,\n bottlenecked on # of connections\n\nWe cannot possibly solve all of the above at once, but to the extent\nthat we recognize all 3 use cases, we can build core features which can\nbe adapted to all of them.\n\nI'm also going to pontificate that, for a future solution, we should not\nfocus on write *IO*, but rather on CPU and RAM. The reason for this\nthinking is that, with the latest improvements in hardware and 9.5\nimprovements, it's increasingly rare for machines to be bottlenecked on\nwrites to the transaction log (or the heap). This has some implications\nfor system design. For example, solutions which require all connections\nto go through a single master node do not scale sufficiently to be worth\nbothering with.\n\nOn some other questions from Mason:\n\n> Do we want multiple copies of shards, like the pg_shard approach? Or\n> keep things simpler and leave it up to the DBA to add standbys? \n\nWe want multiple copies of shards created by the sharding system itself.\n Having a separate, and completely orthagonal, redundancy system to the\nsharding system is overly burdensome on the DBA and makes low-data-loss\nHA impossible.\n\n> Do we want to leverage table inheritance? If so, we may want to spend\n> time improving performance for when the number of shards becomes large\n> with what currently exists. If using table inheritance, we could add the\n> ability to specify what node (er, foreign server) the subtable lives on.\n> We could create top level sharding expressions that allow these to be\n> implicitly created.\n\nIMHO, given that we're looking at replacing inheritance because of its\nmany documented limitations, building sharding on top of inheritance\nseems unwise. For example, many sharding systems are hash-based; how\nwould an inheritance system transparently use hash keys?\n\n> Should we allow arbitrary expressions for shards, not just range, list\n> and hash?\n\nThat seems like a 2.0 feature. It also doesn't seem necessary to\nsupport it for the moderately skilled user; that is, requiring a special\nC sharding function for this seems fine to me.\n\n-- \nJosh Berkus\nPostgreSQL Experts Inc.\nhttp://pgexperts.com\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 31 Aug 2015 13:16:21 -0700","msg_from":"Josh Berkus <josh@agliodbs.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 08/31/2015 01:16 PM, Josh Berkus wrote:\n> All, Bruce:\n>\n\n> I'm also going to pontificate that, for a future solution, we should not\n> focus on write *IO*, but rather on CPU and RAM. The reason for this\n> thinking is that, with the latest improvements in hardware and 9.5\n> improvements, it's increasingly rare for machines to be bottlenecked on\n> writes to the transaction log (or the heap). This has some implications\n> for system design. For example, solutions which require all connections\n> to go through a single master node do not scale sufficiently to be worth\n> bothering with.\n\nWe see this already, under very high concurrency (lots of connections, \nmany cores) we often see a significant drop in performance that is not \nrelated to IO in any meaningful way.\n\nJD\n\n\n-- \nCommand Prompt, Inc. - http://www.commandprompt.com/ 503-667-4564\nPostgreSQL Centered full stack support, consulting and development.\nAnnouncing \"I'm offended\" is basically telling the world you can't\ncontrol your own emotions, so everyone else should do it for you.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 31 Aug 2015 13:23:25 -0700","msg_from":"\"Joshua D. Drake\" <jd@commandprompt.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Mon, Aug 31, 2015 at 4:16 PM, Josh Berkus <josh@agliodbs.com> wrote:\n> First, let me put out there that I think the horizontal scaling project\n> which has buy-in from the community and we're working on is infinitely\n> better than the one we're not working on or is an underresourced fork.\n> So we're in agreement on that. However, I think there's a lot of room\n> for discussion; I feel like the FDW approach was decided in exclusive\n> meetings involving a very small number of people. The FDW approach\n> *may* be the right approach, but I'd like to see some rigorous\n> questioning of that before it's final.\n\nIt seems to me that sharding consists of (1) breaking your data set up\ninto shards, (2) possibly replicating some of those shards onto\nmultiple machines, and then (3) being able to access the remote data\nfrom local queries. As far as (1) is concerned, we need declarative\npartitioning, which is being worked on by Amit Langote. As far as (2)\nis concerned, I hope and expect BDR, or technology derived therefrom,\nto eventually fill that need. As far as (3) is concerned, why\nwouldn't we use the foreign data wrapper interface, and specifically\npostgres_fdw? That interface was designed for the explicit purpose of\nallowing access to remote data sources, and a lot of work has been put\ninto it, so it would be highly surprising if we decided to throw that\naway and develop something completely new from the ground up.\n\nIt's true that postgres_fdw doesn't do everything we need yet. The\nnew join pushdown hooks aren't used by postgres_fdw yet, and the API\nitself has some bugs with EvalPlanQual handling. Aggregate pushdown\nis waiting on upper planner path-ification. DML pushdown doesn't\nexist yet, and the hooks that would enable pushdown of ORDER BY\nclauses to the remote side aren't being used by postgres_fdw. But all\nof these things have been worked on. Patches for many of them have\nalready been posted. They have suffered from a certain amount of\nneglect by senior hackers, and perhaps also from a shortage of time on\nthe part of the authors. But an awful lot of the work that is needed\nhere has already been done, if only we could get it committed.\nAggregate pushdown is a notable exception, but abandoning the foreign\ndata wrapper approach in favor of something else won't fix that.\n\nPostgres-XC developed a purpose-built system for talking to other\nnodes instead of using the FDW interface, for the very good reason\nthat the FDW interface did not yet exist at the time that Postgres-XC\nwas created. But several people associated with the XC project have\nsaid, including one on this thread, that if it had existed, they\nprobably would have used it. And it's hard to see why you wouldn't:\nwith XC's approach, the remote data source is presumed to be\nPostgreSQL (or Postgres-XC/XL/X2/whatever); and you can only use the\nfacility as part of a sharding solution. The FDW interface can talk\nto anything, and it can be used for stuff other than sharding, like\nmaking one remote table appear local because you just happen to want\nthat for some reason. This makes the XC approach look rather brittle\nby comparison. I don't blame the XC folks for taking the shortest\npath between two points, but FDWs are better, and we ought to try to\nleverage that.\n\n> Particularly, I'm concerned that we already have two projects in process\n> aimed at horizontal scalability, and it seems like we could bring either\n> (or both) projects to production quality MUCH faster than we could make\n> an FDW-based solution work. These are:\n>\n> * pg_shard\n> * BDR\n>\n> It seems worthwhile, just as a thought experiment, if we can get where\n> we want using those, faster, or by combining those with new FDW features.\n\nI think it's abundantly clear that we need a logical replication\nsolution as part of any horizontal scalability story. People will\nwant to do things like have 10 machines with each piece of data on 3\nof them, and there won't be any reasonable way of doing that without\nlogical replication. I assume that BDR, or some technology derived\nfrom it, will end up in core and solve that problem. I had actually\nhoped we were going to get that in 9.5, but it didn't happen that way.\nStill, I think that getting first single-master, and then eventually\nmulti-master, logical replication in core is absolutely critical. And\nnot just for sharding specifically: replicating your whole database to\nseveral nodes and load-balancing your clients across them isn't\nsharding, but it does give you read scalability and is a good fit for\npeople with geographically dispersed data with good geographical\nlocality. I think a lot of people will want that.\n\nI'm not quite sure yet how we can marry declarative partitioning and\nbetter FDW-pushdown and logical replication into one seamless, easy to\ndeploy solution that requires very low administrator effort. But I am\nsure that each of those things, taken individually, is very useful,\nand that being able to construct a solution from those building blocks\nwould be a big improvement over what we have today. I can't imagine\nthat trying to do one monolithic project that provides all of those\nthings, but only if you combine them in the specific way that the\ndesigner had in mind, is ever going to be successful. People _will_\nwant access to each of those features in an unbundled fashion. And,\ntrying to do them altogether leads to trying to solve too many\nproblems at once. I think the history of Postgres-XC is a cautionary\ntale there.\n\nI don't really understand how pg_shard fits into this equation. It\nlooks to me like it does some interesting things but, for example, it\ndoesn't support JOIN pushdown, and suggests that you use the\nproprietary CitusDB engine if you need that. But I think JOIN\npushdown is something we want to have in core, not something where we\nwant to point people to proprietary alternatives. And it has some\nrestrictions on INSERT statements - they have to contain only values\nwhich are constants or which can be folded to constants. I'm just\nguessing, but I bet that's probably due to some limitation which\npg_shard, being out of core, has difficulty overcoming, but we can do\nbetter in core. Basically I guess I expect much of what pg_shard does\nto be subsumed as we improve FDWs, but maybe not all of it.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 31 Aug 2015 17:47:12 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"Hi Bruce,\n\nSumedh from Citus Data here.\n\n> August, 2015: While speaking at SFPUG, Citus Data approached me about joining\nthe FDW sharding team. They have been invited to the September 1 meeting,\nas have the XC and XL people.\n\nI'd like to add a clarification. We already tried the FDW APIs for pg_shard\ntwo years ago and failed. We figured sharing our learnings could contribute\nto the technical discussion and that's why we wanted to be in the call.\n\nOzgun summarized our technical learnings in this design document:\nhttps://goo.gl/vJWF85\n\nIn the document, we focused on one of the four learnings we had with FDW\nAPIs. For us, we switched to the hook API based approach, and things went\nsmoothly from there.\n\nBest,\nSumedh\n\nOn Sat, Aug 29, 2015 at 7:17 PM, Bruce Momjian <bruce@momjian.us> wrote:\n\n> I have recently increased my public statements about the idea of adding\n> horizontal scaling/sharding to Postgres. I wanted to share with hackers\n> a timeline of how we got here, and where I think we are going in the\n> short term:\n>\n> 2012-2013: As part of writing my scaling talk\n> (http://momjian.us/main/presentations/overview.html#scaling), studying\n> Oracle RAC, and talking to users, it became clear that an XC-like\n> architecture (sharding) was the only architecture that was going to allow\n> for write scaling.\n>\n> Users and conference attendees I talked to were increasingly concerned\n> about the ability of Postgres to scale for high write volumes. They didn't\n> necessarily need that scale now, but they needed to know they could get\n> it if they wanted it, and wouldn't need to switch to a new database in\n> the future. This is similar to wanting a car that can get you on a highway\n> on-ramp fast --- even if you don't need it, you want to know it is there.\n>\n> 2014: I started to shop around the idea that we could use FDWs,\n> parallelism, and a transaction/snapshot manager to get XC features\n> as built-in to Postgres. (I don't remember where the original idea\n> came from.) It was clear that having separate forks of the source code\n> in XC and XL was never going to achieve critical mass --- there just\n> aren't enough people who need high right scale right now, and the fork\n> maintenance overhead is a huge burden.\n>\n> I realized that we would never get community acceptance to dump the XC\n> (or XL) code needed for sharding into community Postgres, but with FDWs,\n> we could add the features as _part_ of improving FDWs, which would benefit\n> FDWs _and_ would be useful for sharding. (We already see some of those\n> FDW features in 9.5.)\n>\n> October, 2014: EDB and NTT started working together in the community\n> to start improving FDWs as a basis for an FDW-based sharding solution.\n> Many of the 9.5 FDW improvements that also benefit sharding were developed\n> by a combined EDB/NTT team. The features improved FDWs independent of\n> sharding, so they didn't need community buy-in on sharding to get them\n> accepted.\n>\n> June, 2015: I attended the PGCon sharding unconference session and\n> there was a huge discussion about where we should go with sharding.\n> I think the big take-away was that most people liked the FDW approach,\n> but had business/customer reasons for wanting to work on XC or XL because\n> those would be production-ready faster.\n>\n> July, 2015: Oleg Bartunov and his new company Postgres Professional (PP)\n> started to think about joining the FDW approach, rather than working on\n> XL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\n> meeting is scheduled for September 1.\n>\n> August, 2015: While speaking at SFPUG, Citus Data approached me about\n> joining the FDW sharding team. They have been invited to the September\n> 1 meeting, as have the XC and XL people.\n>\n> October, 2015: EDB is sponsoring a free 3-hour summit about FDW sharding\n> at the PG-EU conference in Vienna. Everyone is invited, but it is hoped\n> most of the September 1 folks can attend.\n>\n> February, 2016: Oleg is planning a similar meeting at their February\n> Moscow conference.\n>\n> Anyway, I wanted to explain the work that has been happening around\n> sharding. As things move forward, I am increasingly convinced that write\n> scaling will be needed soon, that the XC approach is the only reasonable\n> way to do it, and that FDWs are the cleanest way to get it into community\n> Postgres.\n>\n> --\n> Bruce Momjian <bruce@momjian.us> http://momjian.us\n> EnterpriseDB http://enterprisedb.com\n>\n> + Everyone has their own god. +\n>\n>\n> --\n> Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\n> To make changes to your subscription:\n> http://www.postgresql.org/mailpref/pgsql-hackers\n>\n\n\n\n-- \n*Sumedh Pathak*\nCitus Data\n650.422.9797\nsumedh@citusdata.com\n\nHi Bruce,Sumedh from Citus Data here.> August, 2015: While speaking at SFPUG, Citus Data approached me about joining the FDW sharding team. They have been invited to the September 1 meeting, as have the XC and XL people.I'd like to add a clarification. We already tried the FDW APIs for pg_shard two years ago and failed. We figured sharing our learnings could contribute to the technical discussion and that's why we wanted to be in the call.Ozgun summarized our technical learnings in this design document: https://goo.gl/vJWF85In the document, we focused on one of the four learnings we had with FDW APIs. For us, we switched to the hook API based approach, and things went smoothly from there.Best,SumedhOn Sat, Aug 29, 2015 at 7:17 PM, Bruce Momjian <bruce@momjian.us> wrote:I have recently increased my public statements about the idea of adding\nhorizontal scaling/sharding to Postgres. I wanted to share with hackers\na timeline of how we got here, and where I think we are going in the\nshort term:\n\n2012-2013: As part of writing my scaling talk\n(http://momjian.us/main/presentations/overview.html#scaling), studying\nOracle RAC, and talking to users, it became clear that an XC-like\narchitecture (sharding) was the only architecture that was going to allow\nfor write scaling.\n\nUsers and conference attendees I talked to were increasingly concerned\nabout the ability of Postgres to scale for high write volumes. They didn't\nnecessarily need that scale now, but they needed to know they could get\nit if they wanted it, and wouldn't need to switch to a new database in\nthe future. This is similar to wanting a car that can get you on a highway\non-ramp fast --- even if you don't need it, you want to know it is there.\n\n2014: I started to shop around the idea that we could use FDWs,\nparallelism, and a transaction/snapshot manager to get XC features\nas built-in to Postgres. (I don't remember where the original idea\ncame from.) It was clear that having separate forks of the source code\nin XC and XL was never going to achieve critical mass --- there just\naren't enough people who need high right scale right now, and the fork\nmaintenance overhead is a huge burden.\n\nI realized that we would never get community acceptance to dump the XC\n(or XL) code needed for sharding into community Postgres, but with FDWs,\nwe could add the features as _part_ of improving FDWs, which would benefit\nFDWs _and_ would be useful for sharding. (We already see some of those\nFDW features in 9.5.)\n\nOctober, 2014: EDB and NTT started working together in the community\nto start improving FDWs as a basis for an FDW-based sharding solution.\nMany of the 9.5 FDW improvements that also benefit sharding were developed\nby a combined EDB/NTT team. The features improved FDWs independent of\nsharding, so they didn't need community buy-in on sharding to get them\naccepted.\n\nJune, 2015: I attended the PGCon sharding unconference session and\nthere was a huge discussion about where we should go with sharding.\nI think the big take-away was that most people liked the FDW approach,\nbut had business/customer reasons for wanting to work on XC or XL because\nthose would be production-ready faster.\n\nJuly, 2015: Oleg Bartunov and his new company Postgres Professional (PP)\nstarted to think about joining the FDW approach, rather than working on\nXL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\nmeeting is scheduled for September 1.\n\nAugust, 2015: While speaking at SFPUG, Citus Data approached me about\njoining the FDW sharding team. They have been invited to the September\n1 meeting, as have the XC and XL people.\n\nOctober, 2015: EDB is sponsoring a free 3-hour summit about FDW sharding\nat the PG-EU conference in Vienna. Everyone is invited, but it is hoped\nmost of the September 1 folks can attend.\n\nFebruary, 2016: Oleg is planning a similar meeting at their February\nMoscow conference.\n\nAnyway, I wanted to explain the work that has been happening around\nsharding. As things move forward, I am increasingly convinced that write\nscaling will be needed soon, that the XC approach is the only reasonable\nway to do it, and that FDWs are the cleanest way to get it into community\nPostgres.\n\n--\n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n--\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n-- Sumedh PathakCitus Data650.422.9797sumedh@citusdata.com","msg_date":"Mon, 31 Aug 2015 16:28:37 -0700","msg_from":"Sumedh Pathak <sumedh@citusdata.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 08/31/2015 02:47 PM, Robert Haas wrote:\n> On Mon, Aug 31, 2015 at 4:16 PM, Josh Berkus <josh@agliodbs.com> wrote:\n>> First, let me put out there that I think the horizontal scaling project\n>> which has buy-in from the community and we're working on is infinitely\n>> better than the one we're not working on or is an underresourced fork.\n>> So we're in agreement on that. However, I think there's a lot of room\n>> for discussion; I feel like the FDW approach was decided in exclusive\n>> meetings involving a very small number of people. The FDW approach\n>> *may* be the right approach, but I'd like to see some rigorous\n>> questioning of that before it's final.\n> \n> It seems to me that sharding consists of (1) breaking your data set up\n> into shards, (2) possibly replicating some of those shards onto\n> multiple machines, and then (3) being able to access the remote data\n> from local queries. As far as (1) is concerned, we need declarative\n> partitioning, which is being worked on by Amit Langote. As far as (2)\n> is concerned, I hope and expect BDR, or technology derived therefrom,\n> to eventually fill that need. \n\nWell, maybe. If you look at pg_shard, you'll see that it works by\nmultiplexing writes to all copies. There's a good reason to do that; it\nallows you to have a tight feedback loop between the success of writes\nand the availability of \"good\" nodes. If you're depending on a separate\nreplication system to handle getting row copies from one shard to\nanother, then you need a different way to deal with bad nodes and with\ninconsistency between copies of shards. That's why the existing\nmultinode non-relational databases don't separate replication from\nwrites, either.\n\nFor that matter, if what you want is transactional fully ACID sharding,\nI really don't see a way to do it via BDR, since BDR is purely\nasynchronous replication, as far as I know.\n\nAlso, if we want BDR to do this, that's pretty far afield of what BDR is\ncurrently capable of, so someone will need to put serious work into it\nrather than just assuming functionality will show up.\n\n> As far as (3) is concerned, why\n> wouldn't we use the foreign data wrapper interface, and specifically\n> postgres_fdw? That interface was designed for the explicit purpose of\n> allowing access to remote data sources, and a lot of work has been put\n> into it, so it would be highly surprising if we decided to throw that\n> away and develop something completely new from the ground up.\n\nWell, query hooks are also a capability which we already have, and is\nmature. Citus has already posted about why they chose to use them instead.\n\nAs long as you recognize that the FDW API (not just the existing fdws)\nwill need to expand to make this work, it's a viable path.\n\nAlso consider that (3) includes both reads and writes.\n\n> I think it's abundantly clear that we need a logical replication\n> solution as part of any horizontal scalability story. People will\n> want to do things like have 10 machines with each piece of data on 3\n> of them, and there won't be any reasonable way of doing that without\n> logical replication. I assume that BDR, or some technology derived\n> from it, will end up in core and solve that problem. I had actually\n> hoped we were going to get that in 9.5, but it didn't happen that way.\n> Still, I think that getting first single-master, and then eventually\n> multi-master, logical replication in core is absolutely critical. And\n> not just for sharding specifically: replicating your whole database to\n> several nodes and load-balancing your clients across them isn't\n> sharding, but it does give you read scalability and is a good fit for\n> people with geographically dispersed data with good geographical\n> locality. I think a lot of people will want that.\n\nWell, the latter thing is something which BDR is designed for, so all\nthat needs to happen with that is getting the rest of the plumbing into\ncore. Also documentation, packaging, productization, etc. But the\nheavy lifting has already been done.\n\nHowever, integrating BDR with sharding has some major design issues\nwhich aren't trivial and may be unresolvable, per above.\n\n> I'm not quite sure yet how we can marry declarative partitioning and\n> better FDW-pushdown and logical replication into one seamless, easy to\n> deploy solution that requires very low administrator effort. But I am\n> sure that each of those things, taken individually, is very useful,\n> and that being able to construct a solution from those building blocks\n> would be a big improvement over what we have today. I can't imagine\n> that trying to do one monolithic project that provides all of those\n> things, but only if you combine them in the specific way that the\n> designer had in mind, is ever going to be successful. People _will_\n> want access to each of those features in an unbundled fashion. And,\n> trying to do them altogether leads to trying to solve too many\n> problems at once. I think the history of Postgres-XC is a cautionary\n> tale there.\n\nYes. It's also a cautionary tale about not skipping over major design\nelements (like HA and DR) until after version 1.0, which is one of the\nreasons I'm harping on certain things here. I don't want us to repeat\nthose mistakes.\n\n> I don't really understand how pg_shard fits into this equation. It\n> looks to me like it does some interesting things but, for example, it\n> doesn't support JOIN pushdown, and suggests that you use the\n> proprietary CitusDB engine if you need that. But I think JOIN\n> pushdown is something we want to have in core, not something where we\n> want to point people to proprietary alternatives. And it has some\n> restrictions on INSERT statements - they have to contain only values\n> which are constants or which can be folded to constants. I'm just\n> guessing, but I bet that's probably due to some limitation which\n> pg_shard, being out of core, has difficulty overcoming, but we can do\n> better in core. Basically I guess I expect much of what pg_shard does\n> to be subsumed as we improve FDWs, but maybe not all of it.\n\npg_shard provides an alternate implementation based on planner hooks\ninstead of FDWs. Even if you pursue an FDW-based design, you should\nlook at (a) why the Citus team found FDWs to be unworkable and (b) what\ngot implemented in planner hooks. Otherwise you're liable to repeat the\nexact same \"learning experience\".\n\n-- \nJosh Berkus\nPostgreSQL Experts Inc.\nhttp://pgexperts.com\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 31 Aug 2015 17:10:11 -0700","msg_from":"Josh Berkus <josh@agliodbs.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Mon, Aug 31, 2015 at 05:10:11PM -0700, Josh Berkus wrote:\n> > As far as (3) is concerned, why\n> > wouldn't we use the foreign data wrapper interface, and specifically\n> > postgres_fdw? That interface was designed for the explicit purpose of\n> > allowing access to remote data sources, and a lot of work has been put\n> > into it, so it would be highly surprising if we decided to throw that\n> > away and develop something completely new from the ground up.\n> \n> Well, query hooks are also a capability which we already have, and is\n> mature. Citus has already posted about why they chose to use them instead.\n> \n> As long as you recognize that the FDW API (not just the existing fdws)\n> will need to expand to make this work, it's a viable path.\n\nUh, we already have a list of things we need to add to FDWs to make them\nwork, and Citus Data has provided a document of more things that are\nneeded, https://goo.gl/vJWF85. I am not sure how much bigger a red flag\nyou want to confirm that everyone agrees that major FDW improvements are\na requirement for this. \n\nMy hope is that many FDW improvements will benefit sharding and\nnon-sharding workloads, but I bet some improvements are going to be\nsharding-specific. I would say we are still in the exploratory stage,\nbut based on the number of people who care about this feature and want\nto be involved, I think we are off to a very good start. :-)\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 31 Aug 2015 20:54:51 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"Bruce Momjian wrote:\n\n> My hope is that many FDW improvements will benefit sharding and\n> non-sharding workloads, but I bet some improvements are going to be\n> sharding-specific. I would say we are still in the exploratory stage,\n> but based on the number of people who care about this feature and want\n> to be involved, I think we are off to a very good start. :-)\n\nHaving lots of interested people doesn't help with some problems,\nthough. The Citus document says:\n\n\tAnd the issue with these four limitations wasn't with foreign\n\tdata wrappers. We wrote mongo_fdw and cstore_fdw, and we're\n\tquite happy with the contract FDWs provide. The problem was that\n\twe were trying to retrofit an API for something that it was\n\tfundamentally not designed to do.\n\n-- \n�lvaro Herrera http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Mon, 31 Aug 2015 23:23:58 -0300","msg_from":"Alvaro Herrera <alvherre@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 2015/09/01 9:54, Bruce Momjian wrote:\n> On Mon, Aug 31, 2015 at 05:10:11PM -0700, Josh Berkus wrote:\n>>> As far as (3) is concerned, why\n>>> wouldn't we use the foreign data wrapper interface, and specifically\n>>> postgres_fdw? That interface was designed for the explicit purpose of\n>>> allowing access to remote data sources, and a lot of work has been put\n>>> into it, so it would be highly surprising if we decided to throw that\n>>> away and develop something completely new from the ground up.\n>>\n>> Well, query hooks are also a capability which we already have, and is\n>> mature. Citus has already posted about why they chose to use them instead.\n>>\n>> As long as you recognize that the FDW API (not just the existing fdws)\n>> will need to expand to make this work, it's a viable path.\n>\n> Uh, we already have a list of things we need to add to FDWs to make them\n> work, and Citus Data has provided a document of more things that are\n> needed, https://goo.gl/vJWF85.\n\nMy top priority is postgres_fdw join pushdown, but I also plan to work \non update pushdown [1] for 9.6, which couldn't make it into 9.5. I \nthink that would resolve the following issue mentioned in the document:\n\n\tUPDATE and DELETE operations are performed by first fetching\n\trecords from the table scanning functions, and then going over\n\tthe fetched records. If the user wanted to update a single row,\n\tthis involved first pulling rows and then updating related\n\trecords.\n\nBest regards,\nEtsuro Fujita\n\n[1] https://commitfest.postgresql.org/4/162/\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 01 Sep 2015 12:30:35 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 3:17 AM, Robert Haas <robertmhaas@gmail.com> wrote:\n\n>\n>\n> It seems to me that sharding consists of (1) breaking your data set up\n> into shards, (2) possibly replicating some of those shards onto\n> multiple machines, and then (3) being able to access the remote data\n> from local queries. As far as (1) is concerned, we need declarative\n> partitioning, which is being worked on by Amit Langote. As far as (2)\n> is concerned, I hope and expect BDR, or technology derived therefrom,\n> to eventually fill that need. As far as (3) is concerned, why\n> wouldn't we use the foreign data wrapper interface, and specifically\n> postgres_fdw? That interface was designed for the explicit purpose of\n> allowing access to remote data sources, and a lot of work has been put\n> into it, so it would be highly surprising if we decided to throw that\n> away and develop something completely new from the ground up.\n>\n> It's true that postgres_fdw doesn't do everything we need yet. The\n> new join pushdown hooks aren't used by postgres_fdw yet, and the API\n> itself has some bugs with EvalPlanQual handling. Aggregate pushdown\n> is waiting on upper planner path-ification. DML pushdown doesn't\n> exist yet, and the hooks that would enable pushdown of ORDER BY\n> clauses to the remote side aren't being used by postgres_fdw. But all\n> of these things have been worked on. Patches for many of them have\n> already been posted. They have suffered from a certain amount of\n> neglect by senior hackers, and perhaps also from a shortage of time on\n> the part of the authors. But an awful lot of the work that is needed\n> here has already been done, if only we could get it committed.\n> Aggregate pushdown is a notable exception, but abandoning the foreign\n> data wrapper approach in favor of something else won't fix that.\n>\n> Postgres-XC developed a purpose-built system for talking to other\n> nodes instead of using the FDW interface, for the very good reason\n> that the FDW interface did not yet exist at the time that Postgres-XC\n> was created. But several people associated with the XC project have\n> said, including one on this thread, that if it had existed, they\n> probably would have used it. And it's hard to see why you wouldn't:\n> with XC's approach, the remote data source is presumed to be\n> PostgreSQL (or Postgres-XC/XL/X2/whatever); and you can only use the\n> facility as part of a sharding solution. The FDW interface can talk\n> to anything, and it can be used for stuff other than sharding, like\n> making one remote table appear local because you just happen to want\n> that for some reason. This makes the XC approach look rather brittle\n> by comparison. I don't blame the XC folks for taking the shortest\n> path between two points, but FDWs are better, and we ought to try to\n> leverage that.\n>\n>\nIn my discussions on this topic with various folks including Robert, I've\nconceded that if FDW was available when XC was first written, in all\nlikelihood we would have used and extended that interface. But that wasn't\nthe case and we did what we thought was the best solution at that time,\ngiven the resources and the schedule. To be honest, when XC project was\nstarted, I was quite skeptical about the whole thing given the goal was to\nbuilt something which can replace Oracle RAC with may be less than 1%\nresources of what Oracle must have invested in building RAC. The lack of\nresources at the start of the project keeps showing up in the quality\nissues that users report from time to time. Having said that, I am quite\nsatisfied with what we have been able to build within the constraints.\n\nBut FDW is just one part of the story. There is this entire global\nconsistency problem that would require something like GTM to give out XIDs\nand snapshots, atomicity which would require managing transactions across\nmultiple shards, join pushdowns when all data is not available locally,\nsomething that XL is attempting to solve with datanode-datanode exchange of\ninformation, other global states such as sequences, replicating some part\nof the data to multiple shards for efficient operations, ability to\nadd/remove shards with least disruption, globally consistent\nbackups/restore. XC/XL has attempted to solve each of them to some extent.\nI don't claim that they are completely solved and there are no corner cases\nleft, but we have made fairly good progress on each of them.\n\nMy worry is that if we start implementing them again from scratch, it will\ntake a few years before we get them in a usable state. What XC/XL lacked is\nprobably a Robert Haas or a Tom Lane who could look at the work and suggest\nmajor edits. If that had happened, the quality of the product could have\nbeen much better today. I don't mean to derate the developers who worked on\nXC/XL, but there is no harm in accepting that if someone with a much better\nunderstanding of the whole system was part of the team, that would have\npositively impacted the project. Is that an angle worth exploring? Does it\nmake sense to commit some more resources to say XC or XL and try to improve\nthe quality of the product even further? To be honest, XL is in far far\nbetter shape (haven't really tried XC in a while) and some more\nQA/polishing can make it production ready much sooner.\n\nYet another possibility is rework the design such that only coordinator\nneeds to be a fork of PostgreSQL but the shards are all PostgreSQL\ninstances, queried using standard client APIs. That would reduce the code\nthat needs to go in the core to build the entire scalable system and also\nshorten the timeline considerably.\n\nThanks,\nPavan\n\n-- \n Pavan Deolasee http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\nOn Tue, Sep 1, 2015 at 3:17 AM, Robert Haas <robertmhaas@gmail.com> wrote:\n\nIt seems to me that sharding consists of (1) breaking your data set up\ninto shards, (2) possibly replicating some of those shards onto\nmultiple machines, and then (3) being able to access the remote data\nfrom local queries. As far as (1) is concerned, we need declarative\npartitioning, which is being worked on by Amit Langote. As far as (2)\nis concerned, I hope and expect BDR, or technology derived therefrom,\nto eventually fill that need. As far as (3) is concerned, why\nwouldn't we use the foreign data wrapper interface, and specifically\npostgres_fdw? That interface was designed for the explicit purpose of\nallowing access to remote data sources, and a lot of work has been put\ninto it, so it would be highly surprising if we decided to throw that\naway and develop something completely new from the ground up.\n\nIt's true that postgres_fdw doesn't do everything we need yet. The\nnew join pushdown hooks aren't used by postgres_fdw yet, and the API\nitself has some bugs with EvalPlanQual handling. Aggregate pushdown\nis waiting on upper planner path-ification. DML pushdown doesn't\nexist yet, and the hooks that would enable pushdown of ORDER BY\nclauses to the remote side aren't being used by postgres_fdw. But all\nof these things have been worked on. Patches for many of them have\nalready been posted. They have suffered from a certain amount of\nneglect by senior hackers, and perhaps also from a shortage of time on\nthe part of the authors. But an awful lot of the work that is needed\nhere has already been done, if only we could get it committed.\nAggregate pushdown is a notable exception, but abandoning the foreign\ndata wrapper approach in favor of something else won't fix that.\n\nPostgres-XC developed a purpose-built system for talking to other\nnodes instead of using the FDW interface, for the very good reason\nthat the FDW interface did not yet exist at the time that Postgres-XC\nwas created. But several people associated with the XC project have\nsaid, including one on this thread, that if it had existed, they\nprobably would have used it. And it's hard to see why you wouldn't:\nwith XC's approach, the remote data source is presumed to be\nPostgreSQL (or Postgres-XC/XL/X2/whatever); and you can only use the\nfacility as part of a sharding solution. The FDW interface can talk\nto anything, and it can be used for stuff other than sharding, like\nmaking one remote table appear local because you just happen to want\nthat for some reason. This makes the XC approach look rather brittle\nby comparison. I don't blame the XC folks for taking the shortest\npath between two points, but FDWs are better, and we ought to try to\nleverage that.\nIn my discussions on this topic with various folks including Robert, I've conceded that if FDW was available when XC was first written, in all likelihood we would have used and extended that interface. But that wasn't the case and we did what we thought was the best solution at that time, given the resources and the schedule. To be honest, when XC project was started, I was quite skeptical about the whole thing given the goal was to built something which can replace Oracle RAC with may be less than 1% resources of what Oracle must have invested in building RAC. The lack of resources at the start of the project keeps showing up in the quality issues that users report from time to time. Having said that, I am quite satisfied with what we have been able to build within the constraints. But FDW is just one part of the story. There is this entire global consistency problem that would require something like GTM to give out XIDs and snapshots, atomicity which would require managing transactions across multiple shards, join pushdowns when all data is not available locally, something that XL is attempting to solve with datanode-datanode exchange of information, other global states such as sequences, replicating some part of the data to multiple shards for efficient operations, ability to add/remove shards with least disruption, globally consistent backups/restore. XC/XL has attempted to solve each of them to some extent. I don't claim that they are completely solved and there are no corner cases left, but we have made fairly good progress on each of them. My worry is that if we start implementing them again from scratch, it will take a few years before we get them in a usable state. What XC/XL lacked is probably a Robert Haas or a Tom Lane who could look at the work and suggest major edits. If that had happened, the quality of the product could have been much better today. I don't mean to derate the developers who worked on XC/XL, but there is no harm in accepting that if someone with a much better understanding of the whole system was part of the team, that would have positively impacted the project. Is that an angle worth exploring? Does it make sense to commit some more resources to say XC or XL and try to improve the quality of the product even further? To be honest, XL is in far far better shape (haven't really tried XC in a while) and some more QA/polishing can make it production ready much sooner.Yet another possibility is rework the design such that only coordinator needs to be a fork of PostgreSQL but the shards are all PostgreSQL instances, queried using standard client APIs. That would reduce the code that needs to go in the core to build the entire scalable system and also shorten the timeline considerably.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services","msg_date":"Tue, 1 Sep 2015 09:30:41 +0530","msg_from":"Pavan Deolasee <pavan.deolasee@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 2015-08-31 20:54:51 -0400, Bruce Momjian wrote:\n> Uh, we already have a list of things we need to add to FDWs to make them\n> work, and Citus Data has provided a document of more things that are\n> needed, https://goo.gl/vJWF85. I am not sure how much bigger a red flag\n> you want to confirm that everyone agrees that major FDW improvements are\n> a requirement for this.\n\nSeveral people saying that the FDW infrastructure isn't sufficient right\nnow is pretty far from implying that all of them agree that the FDW API\nis the way to go.\n\nI'm not sure myself. If it works out it's going to save us some work and\nmake it more realistic to get there sometime not too far off. But I'm\nafraid that the resulting system will feel like our current partitioning\nimplemenentation. Yes, it kinda works, but it's hard to get started, it\ndoesn't support too many features and you're kind afraid your relatives\nwill see what you've done.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 10:15:27 +0200","msg_from":"Andres Freund <andres@anarazel.de>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Mon, Aug 31, 2015 at 01:16:21PM -0700, Josh Berkus wrote:\n> I'm also going to pontificate that, for a future solution, we should not\n> focus on write *IO*, but rather on CPU and RAM. The reason for this\n> thinking is that, with the latest improvements in hardware and 9.5\n> improvements, it's increasingly rare for machines to be bottlenecked on\n> writes to the transaction log (or the heap). This has some implications\n> for system design. For example, solutions which require all connections\n> to go through a single master node do not scale sufficiently to be worth\n> bothering with.\n\nWell, I highlighted write IO for sharding because sharding is the only\nsolution that allows write scaling. If we want to scale CPU, we are\nbetter off using server parallelism, and to scale CPU and RAM, a\nmulti-master/BDR solution seems best. (Multi-master doesn't do write\nscaling because you eventually have to write all the data to each node.)\n\nFor read-scaling, having the read queries go to streaming slave seems\nbest.\n\nOnly sharding allows for write scaling, but only in very limited\nuse-cases, where the queries use multiple shards and the\nsharding/communication overhead doesn't overwhelm the benefits.\n\nFor these reasons, I think sharding has a limited use, and hence, I\ndon't think the community will be willing to add a lot of code just to\nenable auto-sharding. I think it has to be done in a way that adding\nsharding also gives other benefits, like better FDWs and cross-node ACID\ncontrol.\n\nIn summary, I don't think adding a ton of code just to do sharding will\nbe acceptable. A corollary of that, is that if FDWs are unable to\nprovide useful sharding, I don't see an acceptable way of adding\nbuilt-in sharding to Postgres.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 05:39:09 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 10:15:27AM +0200, Andres Freund wrote:\n> On 2015-08-31 20:54:51 -0400, Bruce Momjian wrote:\n> > Uh, we already have a list of things we need to add to FDWs to make them\n> > work, and Citus Data has provided a document of more things that are\n> > needed, https://goo.gl/vJWF85. I am not sure how much bigger a red flag\n> > you want to confirm that everyone agrees that major FDW improvements are\n> > a requirement for this.\n> \n> Several people saying that the FDW infrastructure isn't sufficient right\n> now is pretty far from implying that all of them agree that the FDW API\n> is the way to go.\n> \n> I'm not sure myself. If it works out it's going to save us some work and\n> make it more realistic to get there sometime not too far off. But I'm\n> afraid that the resulting system will feel like our current partitioning\n> implemenentation. Yes, it kinda works, but it's hard to get started, it\n> doesn't support too many features and you're kind afraid your relatives\n> will see what you've done.\n\nWell, reworking our partitioning system is one of the things required\nfor sharding, so at least we will clean up one mess while we create\nanother. ;-)\n\nSeem my post to Josh Berkus just now --- I think if we don't use FDWs,\nthat sharding is such a limited use-case that we will not implement it\ninside of Postgres.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 05:41:55 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 09:30:41AM +0530, Pavan Deolasee wrote:\n> My worry is that if we start implementing them again from scratch, it will take\n> a few years before we get them in a usable state. What XC/XL lacked is probably\n> a Robert Haas or a Tom Lane who could look at the work and suggest major edits.\n> If that had happened, the quality of the product could have been much better\n> today. I don't mean to derate the developers who worked on XC/XL, but there is\n> no harm in accepting that if someone with a much better understanding of the\n> whole system was part of the team, that would have positively impacted the\n> project. Is that an angle worth exploring? Does it make sense to commit some\n> more resources to say XC or XL and try to improve the quality of the product\n> even further? To be honest, XL is in far far better shape (haven't really tried\n> XC in a while) and some more QA/polishing can make it production ready much\n> sooner.\n\nThere is no question that using XC/XL will get us to a usable solution\nfaster, but see my recent post to Josh Berkus --- the additional code\nwill be so burdensome that I doubt it would be accepted. If it was, I\nbet we would have considered it long ago.\n\nI think the only way we are going to get sharding into Postgres is to do\nit in a way that enhances existing Postgres capabilities. \n\n(I think we got a little too cute in enhancing existing Postgres\ncapabilities to add partitioning, and I think we need to fix that.\nHopefully we don't do the same thing with sharding.)\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 05:48:35 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 01/09/15 21:41, Bruce Momjian wrote:\n>\n> Well, reworking our partitioning system is one of the things required\n> for sharding, so at least we will clean up one mess while we create\n> another. ;-)\n>\n> Seem my post to Josh Berkus just now --- I think if we don't use FDWs,\n> that sharding is such a limited use-case that we will not implement it\n> inside of Postgres.\n>\n\nI'm thinking that partitioning and sharding are two different things:\n\nPartitioning is about reducing the amount of table data accessed and \nalso perhaps easing admin activities (archiving/removing old stuff etc).\n\nSharding is a about parallelism and redundancy...copies of stuff in \ndifferent places and concurrent access by virtue of it being on \ndifferent nodes!\n\nNow *maybe* FDW is a good way to approach this, but really would be nice \nto see a more rigorous analysis (I note that like XC and XL, Greenplum \nlooked at the existing mechanisms around at the time and ended up \nwriting their own). Now I'm aware that things have moved on - but I \nthink there needs to be a proper discussion about design and what we \nthink distributed data/sharding etc should provide *before* grabbing \nhold of FDW as *the answer*!\n\nRegards\n\nMark\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 21:58:11 +1200","msg_from":"Mark Kirkwood <mark.kirkwood@catalyst.net.nz>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Mon, Aug 31, 2015 at 3:08 PM, Alexander Korotkov <\na.korotkov@postgrespro.ru> wrote:\n\n> On Mon, Aug 31, 2015 at 9:48 PM, Mason S <masonlists@gmail.com> wrote:\n>\n>>\n>>> We also a bit disappointed by Huawei position about CSN patch, we hoped\n>>> to use for our XTM.\n>>>\n>>\n>> Disappointed in what way? Moving to some sort of CSN approach seems to\n>> open things up for different future ideas. In the short term, it would mean\n>> replacing potentially large snapshots and longer visibility checks. In the\n>> long term, perhaps CSN could help simplify the design of multi-master\n>> replication schemes.\n>>\n>\n> We are disappointed because at PGCon talk Huawei announced publishing of\n> their CSN patch and further work in this direction together with community.\n> However, it's even not published yet despite all the promises. Nobody from\n> Huawei answers CSN thread in the hackers.\n> So, I think we got nothing from Huawei except teasing and should rely only\n> on ourselves. That is disappointing.\n>\n>\nOh, I see. I was in contact with some of the folks involved a few weeks\nago. The intention is to do a bit more work on the patch and then post it.\nThis should be happening \"soon\".\n\nThanks,\n\nMason\n\nOn Mon, Aug 31, 2015 at 3:08 PM, Alexander Korotkov <a.korotkov@postgrespro.ru> wrote:On Mon, Aug 31, 2015 at 9:48 PM, Mason S <masonlists@gmail.com> wrote: We also a bit disappointed by Huawei position about CSN patch, we hoped to use for our XTM. Disappointed in what way? Moving to some sort of CSN approach seems to open things up for different future ideas. In the short term, it would mean replacing potentially large snapshots and longer visibility checks. In the long term, perhaps CSN could help simplify the design of multi-master replication schemes. We are disappointed because at PGCon talk Huawei announced publishing of their CSN patch and further work in this direction together with community. However, it's even not published yet despite all the promises. Nobody from Huawei answers CSN thread in the hackers.So, I think we got nothing from Huawei except teasing and should rely only on ourselves. That is disappointing.Oh, I see. I was in contact with some of the folks involved a few weeks ago. The intention is to do a bit more work on the patch and then post it. This should be happening \"soon\".Thanks,Mason","msg_date":"Tue, 1 Sep 2015 06:47:21 -0400","msg_from":"Mason S <masonlists@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Mon, Aug 31, 2015 at 11:23:58PM -0300, Alvaro Herrera wrote:\n> Bruce Momjian wrote:\n> \n> > My hope is that many FDW improvements will benefit sharding and\n> > non-sharding workloads, but I bet some improvements are going to be\n> > sharding-specific. I would say we are still in the exploratory stage,\n> > but based on the number of people who care about this feature and want\n> > to be involved, I think we are off to a very good start. :-)\n> \n> Having lots of interested people doesn't help with some problems,\n> though. The Citus document says:\n> \n> \tAnd the issue with these four limitations wasn't with foreign\n> \tdata wrappers. We wrote mongo_fdw and cstore_fdw, and we're\n> \tquite happy with the contract FDWs provide. The problem was that\n> \twe were trying to retrofit an API for something that it was\n> \tfundamentally not designed to do.\n\nI had a chance to review the Citus Data document just now:\n\n\thttps://goo.gl/vJWF85\n\nParticularly, it links to this document, which is clearer about the\nissues they are trying to solve:\n\n\thttps://www.citusdata.com/blog/114-how-to-build-your-distributed-database\n\nThe document opens a big question --- when queries can't be processed in\na traditional top/down fashion, Citus has the goal of sending groups of\nresults up the the coordinator, reordering them, then sending them back\nto the shards for further processing, basically using the shards as\ncompute engines because the shards are no longer using local data to do\ntheir computations. The two examples they give are COUNT(DISTINCT) and\na join across two sharded tables (\"CANADA\").\n\nI assumed these queries were going to be solved by sending as digested\ndata as possible to the coordinator, and having the coordinator complete\nany remaining processing. I think we are going to need to decide if\nsuch \"sending data back to shards\" is something we are ever going to\nimplement. I can see FDWs _not_ working well for that use-case.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 06:55:27 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 6:55 AM, Bruce Momjian <bruce@momjian.us> wrote:\n\n> On Mon, Aug 31, 2015 at 11:23:58PM -0300, Alvaro Herrera wrote:\n> > Bruce Momjian wrote:\n> >\n> > > My hope is that many FDW improvements will benefit sharding and\n> > > non-sharding workloads, but I bet some improvements are going to be\n> > > sharding-specific. I would say we are still in the exploratory stage,\n> > > but based on the number of people who care about this feature and want\n> > > to be involved, I think we are off to a very good start. :-)\n> >\n> > Having lots of interested people doesn't help with some problems,\n> > though. The Citus document says:\n> >\n> > And the issue with these four limitations wasn't with foreign\n> > data wrappers. We wrote mongo_fdw and cstore_fdw, and we're\n> > quite happy with the contract FDWs provide. The problem was that\n> > we were trying to retrofit an API for something that it was\n> > fundamentally not designed to do.\n>\n> I had a chance to review the Citus Data document just now:\n>\n> https://goo.gl/vJWF85\n>\n> Particularly, it links to this document, which is clearer about the\n> issues they are trying to solve:\n>\n>\n> https://www.citusdata.com/blog/114-how-to-build-your-distributed-database\n>\n> The document opens a big question --- when queries can't be processed in\n> a traditional top/down fashion, Citus has the goal of sending groups of\n> results up the the coordinator, reordering them, then sending them back\n> to the shards for further processing, basically using the shards as\n> compute engines because the shards are no longer using local data to do\n> their computations. The two examples they give are COUNT(DISTINCT) and\n> a join across two sharded tables (\"CANADA\").\n>\n> I assumed these queries were going to be solved by sending as digested\n> data as possible to the coordinator, and having the coordinator complete\n> any remaining processing. I think we are going to need to decide if\n> such \"sending data back to shards\" is something we are ever going to\n> implement. I can see FDWs _not_ working well for that use-case.\n>\n>\nFor efficient internodes joins with row shipping, FDWs may also not be easy\nto do. Maybe it is possible if we optionally pass in lists of other nodes\nand information about how they are partitioned so data knows where to get\nshipped.\n\nA challenge for planning with arbitrary copies of different shards is that\nsometimes you may be able to push down joins, sometimes not. Planning and\nexecution get ugly. Maybe this can be simplified by parent-child tables\nfollowing the same partitioning scheme.\n\nMason\n\nOn Tue, Sep 1, 2015 at 6:55 AM, Bruce Momjian <bruce@momjian.us> wrote:On Mon, Aug 31, 2015 at 11:23:58PM -0300, Alvaro Herrera wrote:\n> Bruce Momjian wrote:\n>\n> > My hope is that many FDW improvements will benefit sharding and\n> > non-sharding workloads, but I bet some improvements are going to be\n> > sharding-specific. I would say we are still in the exploratory stage,\n> > but based on the number of people who care about this feature and want\n> > to be involved, I think we are off to a very good start. :-)\n>\n> Having lots of interested people doesn't help with some problems,\n> though. The Citus document says:\n>\n> And the issue with these four limitations wasn't with foreign\n> data wrappers. We wrote mongo_fdw and cstore_fdw, and we're\n> quite happy with the contract FDWs provide. The problem was that\n> we were trying to retrofit an API for something that it was\n> fundamentally not designed to do.\n\nI had a chance to review the Citus Data document just now:\n\n https://goo.gl/vJWF85\n\nParticularly, it links to this document, which is clearer about the\nissues they are trying to solve:\n\n https://www.citusdata.com/blog/114-how-to-build-your-distributed-database\n\nThe document opens a big question --- when queries can't be processed in\na traditional top/down fashion, Citus has the goal of sending groups of\nresults up the the coordinator, reordering them, then sending them back\nto the shards for further processing, basically using the shards as\ncompute engines because the shards are no longer using local data to do\ntheir computations. The two examples they give are COUNT(DISTINCT) and\na join across two sharded tables (\"CANADA\").\n\nI assumed these queries were going to be solved by sending as digested\ndata as possible to the coordinator, and having the coordinator complete\nany remaining processing. I think we are going to need to decide if\nsuch \"sending data back to shards\" is something we are ever going to\nimplement. I can see FDWs _not_ working well for that use-case.\nFor efficient internodes joins with row shipping, FDWs may also not be easy to do. Maybe it is possible if we optionally pass in lists of other nodes and information about how they are partitioned so data knows where to get shipped. A challenge for planning with arbitrary copies of different shards is that sometimes you may be able to push down joins, sometimes not. Planning and execution get ugly. Maybe this can be simplified by parent-child tables following the same partitioning scheme.Mason","msg_date":"Tue, 1 Sep 2015 07:01:35 -0400","msg_from":"Mason S <masonlists@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 09/01/2015 02:48 AM, Bruce Momjian wrote:\n> On Tue, Sep 1, 2015 at 09:30:41AM +0530, Pavan Deolasee wrote:\n\n> There is no question that using XC/XL will get us to a usable solution\n> faster, but see my recent post to Josh Berkus --- the additional code\n> will be so burdensome that I doubt it would be accepted. If it was, I\n> bet we would have considered it long ago.\n>\n> I think the only way we are going to get sharding into Postgres is to do\n> it in a way that enhances existing Postgres capabilities.\n\nSo that we have XL again?\n\nThis reads like: We don't want to merge a bunch of code that a non .Org \nproject wrote. Instead we want to write a bunch of code that will all \nbut duplicate what that other project wrote because.... ?\n\nDon't get me wrong, I am all about this goal and if XL truly doesn't fit \nthat's cool but I think the idea that our project will somehow reinvent \na better wheel is naive.\n\n> (I think we got a little too cute in enhancing existing Postgres\n> capabilities to add partitioning, and I think we need to fix that.\n> Hopefully we don't do the same thing with sharding.)\n\nNot cute, lazy. We implemented the barest minimum within our existing \ninfrastructure and we have been kicking ourselves ever since.\n\nSincerely,\n\nJD\n\n\n\n-- \nCommand Prompt, Inc. - http://www.commandprompt.com/ 503-667-4564\nPostgreSQL Centered full stack support, consulting and development.\nAnnouncing \"I'm offended\" is basically telling the world you can't\ncontrol your own emotions, so everyone else should do it for you.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 08:18:38 -0700","msg_from":"\"Joshua D. Drake\" <jd@commandprompt.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 09/01/2015 02:58 AM, Mark Kirkwood wrote:\n> On 01/09/15 21:41, Bruce Momjian wrote:\n\n> I'm thinking that partitioning and sharding are two different things:\n>\n> Partitioning is about reducing the amount of table data accessed and\n> also perhaps easing admin activities (archiving/removing old stuff etc).\n>\n> Sharding is a about parallelism and redundancy...copies of stuff in\n> different places and concurrent access by virtue of it being on\n> different nodes!\n\nIn our world, they are complimentary. Consider partitioning that uses \nFDW tables with proper plan push down etc....\n\n>\n> Now *maybe* FDW is a good way to approach this, but really would be nice\n> to see a more rigorous analysis (I note that like XC and XL, Greenplum\n> looked at the existing mechanisms around at the time and ended up\n> writing their own). Now I'm aware that things have moved on - but I\n> think there needs to be a proper discussion about design and what we\n> think distributed data/sharding etc should provide *before* grabbing\n> hold of FDW as *the answer*!\n\nAgreed.\n\nSincerely,\n\nJoshua D. Drake\n\n\n\n-- \nCommand Prompt, Inc. - http://www.commandprompt.com/ 503-667-4564\nPostgreSQL Centered full stack support, consulting and development.\nAnnouncing \"I'm offended\" is basically telling the world you can't\ncontrol your own emotions, so everyone else should do it for you.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 08:20:12 -0700","msg_from":"\"Joshua D. Drake\" <jd@commandprompt.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 01, 2015 at 10:15:27AM +0200, Andres Freund wrote:\n> On 2015-08-31 20:54:51 -0400, Bruce Momjian wrote:\n> > Uh, we already have a list of things we need to add to FDWs to make them\n> > work, and Citus Data has provided a document of more things that are\n> > needed, https://goo.gl/vJWF85. I am not sure how much bigger a red flag\n> > you want to confirm that everyone agrees that major FDW improvements are\n> > a requirement for this.\n> \n> Several people saying that the FDW infrastructure isn't sufficient right\n> now is pretty far from implying that all of them agree that the FDW API\n> is the way to go.\n> \n> I'm not sure myself. If it works out it's going to save us some work and\n> make it more realistic to get there sometime not too far off. But I'm\n> afraid that the resulting system will feel like our current partitioning\n> implemenentation. Yes, it kinda works, but it's hard to get started, it\n> doesn't support too many features and you're kind afraid your relatives\n> will see what you've done.\n\nWhatever we decide on, we can only count on built-in multi-node being\nadopted if all the needed bits needed ship with every PostgreSQL\ninstallation. If we require people do Install More Software™ in order\nto get a feature, we're going to lose a majority of our potential\nbase.\n\nIf it turns out we need the PostgreSQL FDW, and I believe some\nconsensus is starting to gel around that, I can see not installing it\nin template1 by default. Even that's a questionable decision, as\nmerely having the software in place does not credibly increase the\nattack surface, and does up the installation procedures by a fallible\nstep.\n\nCheers,\nDavid.\n-- \nDavid Fetter <david@fetter.org> http://fetter.org/\nPhone: +1 415 235 3778 AIM: dfetter666 Yahoo!: dfetter\nSkype: davidfetter XMPP: david.fetter@gmail.com\n\nRemember to vote!\nConsider donating to Postgres: http://www.postgresql.org/about/donate\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 08:54:05 -0700","msg_from":"David Fetter <david@fetter.org>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 12:00 AM, Pavan Deolasee\n<pavan.deolasee@gmail.com> wrote:\n> My worry is that if we start implementing them again from scratch, it will\n> take a few years before we get them in a usable state. What XC/XL lacked is\n> probably a Robert Haas or a Tom Lane who could look at the work and suggest\n> major edits. If that had happened, the quality of the product could have\n> been much better today. I don't mean to derate the developers who worked on\n> XC/XL, but there is no harm in accepting that if someone with a much better\n> understanding of the whole system was part of the team, that would have\n> positively impacted the project. Is that an angle worth exploring? Does it\n> make sense to commit some more resources to say XC or XL and try to improve\n> the quality of the product even further? To be honest, XL is in far far\n> better shape (haven't really tried XC in a while) and some more QA/polishing\n> can make it production ready much sooner.\n\n From my point of view, and EnterpriseDB's point of view, anything that\ndoesn't go into the core PostgreSQL distribution isn't really getting\nus where we need to be. If there's code in XL that would be valuable\nto merge into core PostgreSQL, then let's do it. If the code cannot\nbe used but there are lessons we can learn that will make what does go\ninto core PostgreSQL better, let's learn them. However, I don't think\nit's serving anybody very well that we have the XC fork, and multiple\nforks of the XC fork, floating around out there and people are working\non those instead of working on core PostgreSQL. The reality is that\nwe don't have enough brainpower to spread it across 2 or 3 or 4 or 5\ndifferent projects and have all of them be good. The reality is,\nalso, that horizontal scalability isn't an optional feature. There\nwas a point in time at which the PostgreSQL project's official policy\non replication was that it did not belong in core. That was a bad\npolicy; thankfully, it was reversed, and the result was Hot Standby\nand Streaming Replication, incredibly important technologies without\nwhich we would not be where we are today. Horizontal scalability is\njust as essential.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 12:08:05 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 4:15 AM, Andres Freund <andres@anarazel.de> wrote:\n> On 2015-08-31 20:54:51 -0400, Bruce Momjian wrote:\n>> Uh, we already have a list of things we need to add to FDWs to make them\n>> work, and Citus Data has provided a document of more things that are\n>> needed, https://goo.gl/vJWF85. I am not sure how much bigger a red flag\n>> you want to confirm that everyone agrees that major FDW improvements are\n>> a requirement for this.\n>\n> Several people saying that the FDW infrastructure isn't sufficient right\n> now is pretty far from implying that all of them agree that the FDW API\n> is the way to go.\n>\n> I'm not sure myself. If it works out it's going to save us some work and\n> make it more realistic to get there sometime not too far off. But I'm\n> afraid that the resulting system will feel like our current partitioning\n> implemenentation. Yes, it kinda works, but it's hard to get started, it\n> doesn't support too many features and you're kind afraid your relatives\n> will see what you've done.\n\nI'm not averse to making the \"connect to the remote nodes\" part of\nthis solution use something other than the FDW infrastructure at some\npoint in time if somebody's prepared to build something better. On\nthe other hand, I think it's extremely clear that the FDW\ninfrastructure has a large amount of potential upon which we have\nthoroughly failed to capitalize. Patches have already been written\nfor UPDATE/DELETE pushdown and for join pushdown. Those patches have\nbeen around for some time, but progress has been slow. Core\ninfrastructure exists to allow sort pushdown, but nobody's done\nanything with it. Aggregate pushdown hasn't happened yet due to the\ndependency on upper planner path-ification, but it's not as if some\nalternative to the FDW interface is going to dodge that problem.\n\nIt would be a bad idea to cling blindly to the FDW infrastructure if\nit's fundamentally inadequate to do what we want. On the other hand,\nit would also be a bad idea to set about recreating it without a\nreally good reason, and - just to take one example - the fact that it\ndoesn't currently push down DML operations to the remote side is not a\nreally good reason to rewrite the whole thing. On the contrary, it's\na reason to put some energy into the already-written patch which\nimplements that optimization.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 12:18:43 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 09/01/2015 09:08 AM, Robert Haas wrote:\n> On Tue, Sep 1, 2015 at 12:00 AM, Pavan Deolasee\n\n> From my point of view, and EnterpriseDB's point of view, anything that\n> doesn't go into the core PostgreSQL distribution isn't really getting\n> us where we need to be. If there's code in XL that would be valuable\n> to merge into core PostgreSQL, then let's do it. If the code cannot\n> be used but there are lessons we can learn that will make what does go\n> into core PostgreSQL better, let's learn them.\n\nI think that is pretty much anybody in the industry's point of view and \nI agree with it. Although there is definitely an argument to be had \nabout whether it is a module or it is in core proper, no matter what it \nshould be a .Org project.\n\nYou are also correct on the replication statement. Replication should \nhave never been outside of core and I say that as the company that wrote \na replication solution that even Fortune 50 companies used.\n\nI think that we should consider that there are very smart, very talented \nengineers already devoting time to their respective communities (XL/XC) \nthat may very much enjoy being part of our community so we don't have to \nreinvent the wheel, again.\n\nJD\n\n-- \nCommand Prompt, Inc. - http://www.commandprompt.com/ 503-667-4564\nPostgreSQL Centered full stack support, consulting and development.\nAnnouncing \"I'm offended\" is basically telling the world you can't\ncontrol your own emotions, so everyone else should do it for you.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 09:40:18 -0700","msg_from":"\"Joshua D. Drake\" <jd@commandprompt.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 6:55 AM, Bruce Momjian <bruce@momjian.us> wrote:\n> I assumed these queries were going to be solved by sending as digested\n> data as possible to the coordinator, and having the coordinator complete\n> any remaining processing. I think we are going to need to decide if\n> such \"sending data back to shards\" is something we are ever going to\n> implement. I can see FDWs _not_ working well for that use-case.\n\nI do think we are going to want to support that. All the people I've\ntalked to about parallel and distributed query processing agree that\nyou need to do that sort of thing to get really good and scalable\nperformance. I think that we could make a lot of headway as compared\nwith the status quo just by implementing more pushdown optimizations\nthan we have today. Right now, SELECT COUNT(*) FROM table will suck\nback the whole remote table and count the rows locally, and that's\nstupid. We can fix that case with better pushdown logic. We can also\nfix the case of N-way join nests where the joins are either on the\npartitioning key or to replicated tables. But suppose you have a join\nbetween two tables which are sharded across the cluster but not on the\npartitioning key. There's no way to push the join down, so all the\nwork comes back to the coordinator, which is possibly OK if such\nqueries are rare, but not so hot if they are frequent.\n\nTo leverage the full CPU power of the cluster in such a case, you need\nto be able to shuffle data around between the nodes. You pick one of\nthe two tables being joined, and based on the partitioning key of that\ntable, each node examines the other table and, for each row, sends it\nto the machine where it MIGHT have one or more join partners. Then\neach node can join its shard of the first table against the rows from\nthe second table that were sent to it.\n\nNow the question is, where should the code that does all of this live?\n postgres_fdw? Some new, sharding-specific FDW? In core? I don't\nknow for sure, but what I do know is that we could make a lot of\nprogress over where we are today by just improving postgres_fdw, and I\ndon't think those improvements are even all that difficult. If we\ndecide we need to implement something new, it's going to be a huge\nproject that will take years to complete, with uncertain results. I'd\nrather have a postgres_fdw-based implementation that is imperfect and\ncan't handle some kinds of queries in 9.6 than a promise that by 9.9\nwe'll have something really great that handles MPP perfectly.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 12:40:40 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 7:01 AM, Mason S <masonlists@gmail.com> wrote:\n> For efficient internodes joins with row shipping, FDWs may also not be easy\n> to do. Maybe it is possible if we optionally pass in lists of other nodes\n> and information about how they are partitioned so data knows where to get\n> shipped.\n>\n> A challenge for planning with arbitrary copies of different shards is that\n> sometimes you may be able to push down joins, sometimes not. Planning and\n> execution get ugly. Maybe this can be simplified by parent-child tables\n> following the same partitioning scheme.\n\nThis gets at a problem which Ozgun also mentioned in his Google\ndocument, and which I also discussed with Etsuro Fujita at PGCon: good\nquery planning requires good metadata, and we don't really have that\ntoday.\n\nI think that a big part of the goal of the declarative partitioning\nwork that Amit Langote has recently been undertaking is to provide a\ncatalog representation of the partitioning structure that is easy to\nwork with, as opposed to just having a bunch of CHECK constraints that\nyou have to try to reason about. That's one part of the solution.\n\nYou also might need to know more about the remote table than is\ncaptured by the column and data type list. Most particularly, you\nmight want to know what indexes exist on the remote side, but\ncurrently, to figure out that out, you'd need to send queries to\nretrieve that information to the remote side every time you do\nplanning, or maybe you could contrive a session-lifespan cache.\nThat's pretty annoying.\n\nOne idea for solving this problem is to allow CREATE INDEX on foreign\ntables, but I don't like that much. There's no guarantee that the\nremote side is a PostgreSQL instance, and if it isn't, the relevant\ndetails about the indexes that exist may not be convenient to\nrepresent in our catalogs. Heck, that can be true even if it is a\nPostgreSQL instance, if the remote side relies on an AM or a function\nthat doesn't exist locally. But even if both sides are PostgreSQL\ninstances using only btree indexes on raw columns, now you've put the\nburden on the DBA to make sure that the index definitions on the local\nand remote sides match, and that's a pain in the neck.\n\nWhat seems better to me is to allow ANALYZE of a foreign table a place\nto record an arbitrary blob of metadata about the remote side that it\ncan then get access to during planning. Then, you can record details\nabout indexes, or statistics that don't fit into the mold of\npg_statistic, or really, anything else you're going to need to figure\nout the best plan, and if the DBA changes the configuration on the\nremote side, they don't need to update the local configuration to\nmatch; a re-ANALYZE will do the trick.\n\nI'm open to other ideas as well. Repartitioning will also arise for\nan all-local parallel join, and it would be nice if the planner smarts\ncould be shared between that case and the remote-table case.\nTherefore, while I suspect that some of the logic here will end up\ninside one or more FDWs, I'm pretty confident that a significant chunk\nof it needs to go into the core optimizer.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 13:00:06 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 09/01/2015 02:39 AM, Bruce Momjian wrote:\n> On Mon, Aug 31, 2015 at 01:16:21PM -0700, Josh Berkus wrote:\n>> I'm also going to pontificate that, for a future solution, we should not\n>> focus on write *IO*, but rather on CPU and RAM. The reason for this\n>> thinking is that, with the latest improvements in hardware and 9.5\n>> improvements, it's increasingly rare for machines to be bottlenecked on\n>> writes to the transaction log (or the heap). This has some implications\n>> for system design. For example, solutions which require all connections\n>> to go through a single master node do not scale sufficiently to be worth\n>> bothering with.\n> \n> Well, I highlighted write IO for sharding because sharding is the only\n> solution that allows write scaling. If we want to scale CPU, we are\n> better off using server parallelism, and to scale CPU and RAM, a\n> multi-master/BDR solution seems best. (Multi-master doesn't do write\n> scaling because you eventually have to write all the data to each node.)\n\nYou're assuming that our primary bottleneck for writes is IO. It's not\nat present for most users, and it certainly won't be in the future. You\nneed to move your thinking on systems resources into the 21st century,\ninstead of solving the resource problems from 15 years ago.\n\nCurrently, CPU resources and locking are the primary bottlenecks on\nwriting for the vast majority of the hundreds of servers I tune every\nyear. This even includes AWS, with EBS's horrible latency; even in that\nenvironment, most users can outstrip PostgreSQL's ability to handle\nrequests by getting 20K PRIOPs.\n\nOur real future bottlenecks are:\n\n* ability to handle more than a few hundred connections\n* locking limits on the scalability of writes\n* ability to manage large RAM and data caches\n\n\nThe only place where IO becomes the bottleneck is for the\nbatch-processing, high-throughput DW case ... and I would argue that\nexisting forks already handle that case.\n\nAny sharding solution worth bothering with will solve some or all of the\nabove by extending our ability to process requests across multiple\nnodes. Any solution which does not is merely an academic curiosity.\n\n> For these reasons, I think sharding has a limited use, and hence, I\n> don't think the community will be willing to add a lot of code just to\n> enable auto-sharding. I think it has to be done in a way that adding\n> sharding also gives other benefits, like better FDWs and cross-node ACID\n> control.\n> \n> In summary, I don't think adding a ton of code just to do sharding will\n> be acceptable. A corollary of that, is that if FDWs are unable to\n> provide useful sharding, I don't see an acceptable way of adding\n> built-in sharding to Postgres.\n\nSo, while I am fully in agreement with you that having side benefits to\nour sharding tools, I think you're missing the big picture entirely. In\na few years, clustered/sharded PostgreSQL will be the default\ninstallation, or we'll be a legacy database. Single-node and\nsingle-master databases are rapidly becoming history.\n\n From my perspective, we don't need an awkward, limited, bolt-on solution\nfor write-scaling. We need something which will become core to how\nPostgreSQL works. I just don't see us getting there with the described\nFDW approach, which is why I keep raising issues with it.\n\n-- \nJosh Berkus\nPostgreSQL Experts Inc.\nhttp://pgexperts.com\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 01 Sep 2015 10:06:54 -0700","msg_from":"Josh Berkus <josh@agliodbs.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 1:06 PM, Josh Berkus <josh@agliodbs.com> wrote:\n> You're assuming that our primary bottleneck for writes is IO. It's not\n> at present for most users, and it certainly won't be in the future. You\n> need to move your thinking on systems resources into the 21st century,\n> instead of solving the resource problems from 15 years ago.\n\nYour experience doesn't match mine. I find that it's frequently\nimpossible to get the system to use all of the available CPU capacity,\neither because you're bottlenecked on locks or because you are\nbottlenecked on the I/O subsystem, and with the locking improvements\nin newer versions, the former is becoming less and less common.\nAmit's recent work on scalability demonstrates this trend: he goes\nlooking for lock bottlenecks, and finds problems that only occur at\n128+ concurrent connections running full tilt. The patches show\nlimited benefit - a few percentage points - at lesser concurrency\nlevels. Either there are other locking bottlenecks that limit\nperformance at lower client counts but which mysteriously disappear as\nconcurrency increases, which I would find surprising, or the limit is\nsomewhere else. I haven't seen any convincing evidence that the I/O\nsubsystem is the bottleneck, but I'm having a hard time figuring out\nwhat else it could be.\n\n> Our real future bottlenecks are:\n>\n> * ability to handle more than a few hundred connections\n> * locking limits on the scalability of writes\n> * ability to manage large RAM and data caches\n\nI do agree that all of those things are problems, FWIW.\n\n> Any sharding solution worth bothering with will solve some or all of the\n> above by extending our ability to process requests across multiple\n> nodes. Any solution which does not is merely an academic curiosity.\n\nI think the right solution to those problems is to attack them\nhead-on. Sharding solutions should cater to use cases where using all\nthe resources of one machine isn't sufficient no matter how\nefficiently we do it.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 13:17:36 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 09/01/2015 10:06 AM, Josh Berkus wrote:\n> On 09/01/2015 02:39 AM, Bruce Momjian wrote:\n>> On Mon, Aug 31, 2015 at 01:16:21PM -0700, Josh Berkus wrote:\n\n> Our real future bottlenecks are:\n>\n> * ability to handle more than a few hundred connections\n\nThis, 1000 times this. No a connection pooler doesn't help, we are using \n1000 connections WITH a connection pooler. The amount of data centric, \nalways connected (even if stateless) apps that are out there is \nastounding. Our performance curve is better (especially since Robert's \nfantastic work on 9.2) but it isn't where a lot of the demanding users \nneed to be.\n\nWe are also seeing a vast uptick in always connected apps that aren't \nweb centric (or the client at least isn't). In other words we are seeing \nsituations where 1000 connections is 1000 users, connected.\n\nJD\n\n\n\n-- \nCommand Prompt, Inc. - http://www.commandprompt.com/ 503-667-4564\nPostgreSQL Centered full stack support, consulting and development.\nAnnouncing \"I'm offended\" is basically telling the world you can't\ncontrol your own emotions, so everyone else should do it for you.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 10:17:38 -0700","msg_from":"\"Joshua D. Drake\" <jd@commandprompt.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 09/01/2015 10:17 AM, Robert Haas wrote:\n> On Tue, Sep 1, 2015 at 1:06 PM, Josh Berkus <josh@agliodbs.com> wrote:\n>> Any sharding solution worth bothering with will solve some or all of the\n>> above by extending our ability to process requests across multiple\n>> nodes. Any solution which does not is merely an academic curiosity.\n> \n> I think the right solution to those problems is to attack them\n> head-on. Sharding solutions should cater to use cases where using all\n> the resources of one machine isn't sufficient no matter how\n> efficiently we do it.\n\nAs long as \"all the resources\" != \"just IO\", I'm completely on board\nwith that. The reason I raised this is that the initial FDW-based\nproposals pretty much scale IO and nothing else.\n\npg_shard also currently only scales IO, but they're working on that.\n\n-- \nJosh Berkus\nPostgreSQL Experts Inc.\nhttp://pgexperts.com\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 01 Sep 2015 10:46:17 -0700","msg_from":"Josh Berkus <josh@agliodbs.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"Hi,\n\nOn 09/01/2015 07:17 PM, Robert Haas wrote:\n> On Tue, Sep 1, 2015 at 1:06 PM, Josh Berkus <josh@agliodbs.com> wrote:\n>> You're assuming that our primary bottleneck for writes is IO. It's\n>> not at present for most users, and it certainly won't be in the\n>> future. You need to move your thinking on systems resources into\n>> the 21st century, instead of solving the resource problems from 15\n>> years ago.\n>\n> Your experience doesn't match mine. I find that it's frequently\n> impossible to get the system to use all of the available CPU\n> capacity, either because you're bottlenecked on locks or because you\n> are bottlenecked on the I/O subsystem, and with the locking\n> improvements in newer versions, the former is becoming less and less\n> common. Amit's recent work on scalability demonstrates this trend: he\n> goes looking for lock bottlenecks, and finds problems that only occur\n> at 128+ concurrent connections running full tilt. The patches show\n> limited benefit - a few percentage points - at lesser concurrency\n> levels. Either there are other locking bottlenecks that limit\n> performance at lower client counts but which mysteriously disappear\n> as concurrency increases, which I would find surprising, or the limit\n> is somewhere else. I haven't seen any convincing evidence that the\n> I/O subsystem is the bottleneck, but I'm having a hard time figuring\n> out what else it could be.\n\nMemory bandwidth, for example. It's quite difficult to spot, because the \nintuition is that memory is fast, but thanks to improvements in storage \n(and stagnation in RAM bandwidth), this is becoming a significant issue.\n\nProcess-management overhead is another thing we tend to ignore, but once \nyou get to many processes all willing to work at the same time, you need \nto account for that.\n\nOf course, this applies differently to different sharding use cases. For \nexample analytics workloads have serious issues with memory bandwidth, \nbut not so much with process management overhead (because the number of \nconnections is usually about number of cores). Use cases with many \nclients (in web-scale use cases) tends to run into both (all the \nprocesses also have to share all the caches, killing them).\n\nI don't know if sharding can help solving (or at least improve) these \nissues. And if sharding in general can, I don't know if it still holds \nfor FDW-based solution.\n\nregards\n\n--\nTomas Vondra http://www.2ndQuadrant.com\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 01 Sep 2015 20:04:18 +0200","msg_from":"Tomas Vondra <tomas.vondra@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 2:04 PM, Tomas Vondra\n<tomas.vondra@2ndquadrant.com> wrote:\n> Memory bandwidth, for example. It's quite difficult to spot, because the\n> intuition is that memory is fast, but thanks to improvements in storage (and\n> stagnation in RAM bandwidth), this is becoming a significant issue.\n\nI'd appreciate any tips on how to spot problems of this type. But\nit's my impression that perf, top, vmstat, and other Linux performance\ntools will count time spent waiting for memory as CPU time, not idle\ntime. If that's correct, that wouldn't explain workloads where CPU\nutilization doesn't reach 100%. Rather, it would show up as CPU time\nhitting 100% while tps remains low.\n\n> Process-management overhead is another thing we tend to ignore, but once you\n> get to many processes all willing to work at the same time, you need to\n> account for that.\n\nAny tips on spotting problems in that area?\n\nThanks,\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 14:11:21 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 2015-09-01 14:11:21 -0400, Robert Haas wrote:\n> On Tue, Sep 1, 2015 at 2:04 PM, Tomas Vondra\n> <tomas.vondra@2ndquadrant.com> wrote:\n> > Memory bandwidth, for example. It's quite difficult to spot, because the\n> > intuition is that memory is fast, but thanks to improvements in storage (and\n> > stagnation in RAM bandwidth), this is becoming a significant issue.\n> \n> I'd appreciate any tips on how to spot problems of this type. But\n> it's my impression that perf, top, vmstat, and other Linux performance\n> tools will count time spent waiting for memory as CPU time, not idle\n> time. If that's correct, that wouldn't explain workloads where CPU\n> utilization doesn't reach 100%. Rather, it would show up as CPU time\n> hitting 100% while tps remains low.\n\nYea.\n\n-e bus-cycles is a good start to measure where bus traffic is\n relevant. Depending on the individual cpu other events can be helpful.\n\n> > Process-management overhead is another thing we tend to ignore, but once you\n> > get to many processes all willing to work at the same time, you need to\n> > account for that.\n> \n> Any tips on spotting problems in that area?\n\nNot perfect, but -e context-switches (general context switches) and -e\nsyscalls:sys_enter_semop (for postgres enforced context switches) is\nrather useful when combined with --call-graph dwarf ('fp' sometimes\ndoesn't see through libc which is most of the time not compiled with\n-fno-omit-frame-pointer).\n\nGreetings,\n\nAndres Freund\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 20:22:49 +0200","msg_from":"Andres Freund <andres@anarazel.de>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"Hi,\n\nOn 08/31/2015 10:16 PM, Josh Berkus wrote:\n> It's also important to recognize that there are three major use-cases\n> for write-scalable clustering:\n>\n> * OLTP: small-medium cluster, absolute ACID consistency,\n> bottlnecked on small writes per second\n> * DW: small-large cluster, ACID optional,\n> bottlenecked on bulk reads/writes\n> * Web: medium to very large cluster, ACID optional,\n> bottlenecked on # of connections\n>\n> We cannot possibly solve all of the above at once, but to the extent\n> that we recognize all 3 use cases, we can build core features which\n> can be adapted to all of them.\n\nIt would be good to have a discussion about use-cases first - each of us \nis mostly concerned about the use cases they're dealing with, with \nbottlenecks specific to their environment. These three basic use-cases \nseem like a good start, but some of the details certainly don't match my \nexperience ...\n\nFor example I can't see how ACID can be optional for the DWH use-case, \nbut maybe there's a good explanation - I can imagine sacrificing various \nACID properties at the node level, but I can't really imagine \nsacrificing any of the ACID properties for the cluster as a whole. So \nthis would deserve some explanation.\n\nI also don't share the view that write scalability is the only (or even \nmain) issue, that we should aim to solve. For the business-intelligence \nuse cases I've been working on recently, handling complex read-only \nad-hoc queries is often much more important. And in those cases the \nbottleneck is often CPU and/or RAM.\n\n>\n> I'm also going to pontificate that, for a future solution, we should\n> not focus on write *IO*, but rather on CPU and RAM. The reason for\n> this thinking is that, with the latest improvements in hardware and\n> 9.5 improvements, it's increasingly rare for machines to be\n> bottlenecked on writes to the transaction log (or the heap). This has\n> some implications for system design. For example, solutions which\n> require all connections to go through a single master node do not\n> scale sufficiently to be worth bothering with.\n\n+1\n\n> On some other questions from Mason:\n>\n>> Do we want multiple copies of shards, like the pg_shard approach? Or\n>> keep things simpler and leave it up to the DBA to add standbys?\n>\n> We want multiple copies of shards created by the sharding system itself.\n> Having a separate, and completely orthagonal, redundancy system to the\n> sharding system is overly burdensome on the DBA and makes low-data-loss\n> HA impossible.\n\nIMHO it'd be quite unfortunate if the design would make it impossible to \ncombine those two features (e.g. creating standbys for shards and \nfailing over to them).\n\nIt's true that solving HA at the sharding level (by keeping multiple \ncopies of a each shard) may be simpler than combining sharding and \nstandbys, but I don't see why it makes low-data-loss HA impossible.\n\n\nregards\n\n--\nTomas Vondra http://www.2ndQuadrant.com\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 01 Sep 2015 20:36:03 +0200","msg_from":"Tomas Vondra <tomas.vondra@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"Hi,\n\nOn 09/01/2015 08:22 PM, Andres Freund wrote:\n> On 2015-09-01 14:11:21 -0400, Robert Haas wrote:\n>> On Tue, Sep 1, 2015 at 2:04 PM, Tomas Vondra\n>> <tomas.vondra@2ndquadrant.com> wrote:\n>>> Memory bandwidth, for example. It's quite difficult to spot, because the\n>>> intuition is that memory is fast, but thanks to improvements in storage (and\n>>> stagnation in RAM bandwidth), this is becoming a significant issue.\n>>\n>> I'd appreciate any tips on how to spot problems of this type. But\n>> it's my impression that perf, top, vmstat, and other Linux performance\n>> tools will count time spent waiting for memory as CPU time, not idle\n>> time. If that's correct, that wouldn't explain workloads where CPU\n>> utilization doesn't reach 100%. Rather, it would show up as CPU time\n>> hitting 100% while tps remains low.\n>\n> Yea.\n>\n> -e bus-cycles is a good start to measure where bus traffic is\n> relevant. Depending on the individual cpu other events can be helpful.\n\nlong-story: https://people.freebsd.org/~lstewart/articles/cpumemory.pdf\n\nIt's from 2007 and only explains oprofile (chapter 7), which is mostly \nabandoned in favor of perf nowadays. Perf can produce similar stats, so \nthe discussion is still valid. But it also shows cachegrind (valgrind \nmodule).\n\nperf examples: http://www.brendangregg.com/perf.html\n\nMost of the examples with \"CPU\" in the comment are relevant. Usually \n\"perf stat\" and \"perf stat -d\" are good starting points - once you get a \nlot of LLC misses or too many instructions per cycle, it's a sign of \nmemory bandwidth problems.\n\nSadly, this is partially caused by our volcano-style executor and \nsharding alone can do nothing about that.\n\n>\n>>> Process-management overhead is another thing we tend to ignore, but once you\n>>> get to many processes all willing to work at the same time, you need to\n>>> account for that.\n>>\n>> Any tips on spotting problems in that area?\n>\n> Not perfect, but -e context-switches (general context switches) and -e\n> syscalls:sys_enter_semop (for postgres enforced context switches) is\n> rather useful when combined with --call-graph dwarf ('fp' sometimes\n> doesn't see through libc which is most of the time not compiled with\n> -fno-omit-frame-pointer).\n\nRight, this is about the best I'm aware of.\n\nThe problem often is not in the number of context switches, but in the \nfact that all the processes share the same (very limited) L caches on \nthe CPU. Each process dirties the caches for the other processes, \nlowering the hit ratios. Which can be spotted using the commands above.\n\nregards\n\n--\nTomas Vondra http://www.2ndQuadrant.com\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 01 Sep 2015 20:59:11 +0200","msg_from":"Tomas Vondra <tomas.vondra@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 09/01/2015 11:36 AM, Tomas Vondra wrote:\n>> We want multiple copies of shards created by the sharding system itself.\n>> Having a separate, and completely orthagonal, redundancy system to the\n>> sharding system is overly burdensome on the DBA and makes low-data-loss\n>> HA impossible.\n> \n> IMHO it'd be quite unfortunate if the design would make it impossible to\n> combine those two features (e.g. creating standbys for shards and\n> failing over to them).\n> \n> It's true that solving HA at the sharding level (by keeping multiple\n> copies of a each shard) may be simpler than combining sharding and\n> standbys, but I don't see why it makes low-data-loss HA impossible.\n\nOther way around, that is, having replication standbys as the only\nmethod of redundancy requires either high data loss or high latency for\nall writes.\n\nIn the case of async rep, every time we fail over a node, the entire\ncluser would need to roll back to the last common known-good replay\npoint, hence high data loss.\n\nIn the case of sync rep, we are required to wait for at least double\nnetwork lag time in order to do a single write ... making\nwrite-scalability quite difficult.\n\nFuther, if using replication the sharding system would have no way to\n(a) find out immediately if a copy was bad and (b) fail over quickly to\na copy of the shard if the first requested copy was not responding.\nWith async replication, we also can't use multiple copies of the same\nshard as a way to balance read workloads.\n\nIf we write to multiple copies as a part of the sharding feature, then\nthat can be parallelized, so that we are waiting only as long as the\nslowest write (or in failure cases, as long as the shard timeout).\nFurther, we can check for shard-copy health and update shard\navailability data with each user request, so that the ability to see\nstale/bad data is minimized.\n\nThere are obvious problems with multiplexing writes, which you can\nfigure out if you knock pg_shard around a bit. But I really think that\nsolving those problems is the only way to go.\n\nMind you, I see a strong place for binary replication and BDR for\nmulti-region redundancy; you really don't want that to be part of the\nsharding system if you're aiming for write scalability.\n\n-- \nJosh Berkus\nPostgreSQL Experts Inc.\nhttp://pgexperts.com\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 01 Sep 2015 12:19:40 -0700","msg_from":"Josh Berkus <josh@agliodbs.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 3:19 PM, Josh Berkus <josh@agliodbs.com> wrote:\n> Mind you, I see a strong place for binary replication and BDR for\n> multi-region redundancy; you really don't want that to be part of the\n> sharding system if you're aiming for write scalability.\n\nI mostly agree, but keep in mind that you don't have to replicate\neverything. A lot of people might find it useful to replicate the\ndata that is common to all nodes even if they don't replicate the\nsharded data.\n\nAdmittedly, there are some problems with snapshots here: if you don't\ndo anything special about snapshots, then what you have here will be\n\"eventually consistent\" behavior. But that might be suitable for some\nenvironments, such as very loosely coupled system where not all nodes\nare connected all the time. And, for those environments where you do\nneed consistent snapshots, we can imagine ways to get that behavior,\nlike having the GTM consider the transaction uncommitted until it's\nbeen logically replicated to every node.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 16:47:08 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"Hi,\n\nOn 09/01/2015 09:19 PM, Josh Berkus wrote:\n> On 09/01/2015 11:36 AM, Tomas Vondra wrote:\n>>> We want multiple copies of shards created by the sharding system\n>>> itself. Having a separate, and completely orthagonal, redundancy\n>>> system to the sharding system is overly burdensome on the DBA and\n>>> makes low-data-loss HA impossible.\n>>\n>> IMHO it'd be quite unfortunate if the design would make it\n>> impossible to combine those two features (e.g. creating standbys\n>> for shards and failing over to them).\n>>\n>> It's true that solving HA at the sharding level (by keeping\n>> multiple copies of a each shard) may be simpler than combining\n>> sharding and standbys, but I don't see why it makes low-data-loss\n>> HA impossible.\n>\n> Other way around, that is, having replication standbys as the only\n> method of redundancy requires either high data loss or high latency\n> for all writes.\n\nI haven't said that. I said that we should allow that topology, not that \nit should be the only method of redundancy.\n\n>\n> In the case of async rep, every time we fail over a node, the entire\n> cluser would need to roll back to the last common known-good replay\n> point, hence high data loss.\n>\n> In the case of sync rep, we are required to wait for at least double\n> network lag time in order to do a single write ... making\n> write-scalability quite difficult.\n\nWhich assumes that latency (or rather the increase due to syncrep) is a \nproblem for the use case. Which may be the case for many use cases, but \ncertainly is not a problem for many BI/DWH use cases performing mostly \nlarge batch loads. In those cases the network bandwidth may be quite \nimportant resource.\n\nFor example assume that there are just two shards in two separate data \ncenters, connected by a link with limited bandwidth. Now, let's assume \nyou always keep a local replica for failover. So you have A1+A2 in DC1, \nB1+B2 in DC2. If you're in DC1, then writing data to B1 means you also \nhave to write data to B2 and wait for it. So either you send the data to \neach node separately (consuming 2x the bandwidth), or send it to B1 and \nlet it propagate to B2 e.g. through sync rep.\n\nSo while you may be right in single-DC deployments, with multi-DC \ndeployments the situation is quite different - not only that the network \nbandwidth is not unlimited, but because latencies within DC may be a \nfraction of latencies between the locations (to the extent that the \nincrease due to syncrep may be just noise). So the local replication may \nbe actually way faster.\n\nI can imagine forwarding the data between B1 and B2 even with a purely \nsharding solution, but at that point you effectively re-implemented syncrep.\n\nIMHO the design has to address the multi-DC setups somehow. I think that \nmany of the customers who are so concerned about scaling to many shards \nare also concerned about availability in case of DC outages, no?\n\nWe should also consider support for custom topologies (not just a full \nmesh, or whatever we choose as the default/initial topology), which is \nsomehow related.\n\n>\n> Futher, if using replication the sharding system would have no way\n> to (a) find out immediately if a copy was bad and (b) fail over\n> quickly to a copy of the shard if the first requested copy was not\n> responding. With async replication, we also can't use multiple copies\n> of the same shard as a way to balance read workloads.\n\nI don't follow. With sync rep we do know whether the copy is OK or not, \nbecause the node either confirms writes or not. The failover certainly \nis more complicated and is not immediate (to the extent of keeping a \ncopy at the sharding level), but it's a question of trade-offs.\n\nIt's true we don't have auto-failover solution at the moment, but as I \nsaid - I can easily imagine most people using just sharding, while some \ndeployments use syncrep with manual failover.\n\n>\n> If we write to multiple copies as a part of the sharding feature,\n> then that can be parallelized, so that we are waiting only as long as\n> the slowest write (or in failure cases, as long as the shard\n> timeout). Further, we can check for shard-copy health and update\n> shard availability data with each user request, so that the ability\n> to see stale/bad data is minimized.\n\nAgain, this assumes infinite network bandwidth.\n\n>\n> There are obvious problems with multiplexing writes, which you can\n> figure out if you knock pg_shard around a bit. But I really think\n> that solving those problems is the only way to go.\n>\n> Mind you, I see a strong place for binary replication and BDR for\n> multi-region redundancy; you really don't want that to be part of\n> the sharding system if you're aiming for write scalability.\n\nI haven't mentioned BDR at all, and given the async nature I don't have \na clear idea of how it fits into the sharding world at this point.\n\nregards\n\n--\nTomas Vondra http://www.2ndQuadrant.com\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 01 Sep 2015 23:29:52 +0200","msg_from":"Tomas Vondra <tomas.vondra@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 08:18:38AM -0700, Joshua Drake wrote:\n> On 09/01/2015 02:48 AM, Bruce Momjian wrote:\n> >On Tue, Sep 1, 2015 at 09:30:41AM +0530, Pavan Deolasee wrote:\n> \n> >There is no question that using XC/XL will get us to a usable solution\n> >faster, but see my recent post to Josh Berkus --- the additional code\n> >will be so burdensome that I doubt it would be accepted. If it was, I\n> >bet we would have considered it long ago.\n> >\n> >I think the only way we are going to get sharding into Postgres is to do\n> >it in a way that enhances existing Postgres capabilities.\n> \n> So that we have XL again?\n\nKind of. If XC/XL used FDWs I think we would try to use their code\nfirst. The issue is that FDWs didn't exist at the time. I would say\nour first approach might be doing XC/XL again with FDWs.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 17:53:47 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Sep 1, 2015, at 1:47 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n\n> Admittedly, there are some problems with snapshots here: if you don't\n> do anything special about snapshots, then what you have here will be\n> \"eventually consistent\" behavior. But that might be suitable for some\n> environments, such as very loosely coupled system where not all nodes\n> are connected all the time.\n\nGiven that we’re discussing multi-node architectures here, you should expect that not all nodes will be connected at any time. Nodes fail, but the cluster should not.\n\n> And, for those environments where you do\n> need consistent snapshots, we can imagine ways to get that behavior,\n> like having the GTM consider the transaction uncommitted until it's\n> been logically replicated to every node.\n\nAgain, you need a way to deal with nodes going down. I can envision building a cluster with twelve nodes replicated to each of three geographically-distributed data centers. Each replication/sync model needs to be able to handle nodes going up and down, data centers or racks going up or down, and nodes being added and removed.\n\nBut even with smaller clusters, there’s no way around the fact that no system can guarantee that all nodes will be available at all times.\n\nBest,\n\nDavid","msg_date":"Tue, 1 Sep 2015 15:07:41 -0700","msg_from":"\"David E. Wheeler\" <david@justatheory.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 09/01/2015 02:29 PM, Tomas Vondra wrote:\n> Hi,\n> \n> On 09/01/2015 09:19 PM, Josh Berkus wrote:\n>> Other way around, that is, having replication standbys as the only\n>> method of redundancy requires either high data loss or high latency\n>> for all writes.\n> \n> I haven't said that. I said that we should allow that topology, not that\n> it should be the only method of redundancy.\n\nAh, OK, I didn't understand you. Of course I'm in favor of supporting\nboth methods of redundancy if we can.\n\n>> In the case of sync rep, we are required to wait for at least double\n>> network lag time in order to do a single write ... making\n>> write-scalability quite difficult.\n> \n> Which assumes that latency (or rather the increase due to syncrep) is a\n> problem for the use case. Which may be the case for many use cases, but\n> certainly is not a problem for many BI/DWH use cases performing mostly\n> large batch loads. In those cases the network bandwidth may be quite\n> important resource.\n\nI'll argue that BI/DW is the least interesting use case for mainstream\nPostgreSQL because there are production-quality forks which do this\n(mostly propietary, but we can work on that). We really need a solution\nwhich works for OLTP.\n\n> For example assume that there are just two shards in two separate data\n> centers, connected by a link with limited bandwidth. Now, let's assume\n> you always keep a local replica for failover. So you have A1+A2 in DC1,\n> B1+B2 in DC2. If you're in DC1, then writing data to B1 means you also\n> have to write data to B2 and wait for it. So either you send the data to\n> each node separately (consuming 2x the bandwidth), or send it to B1 and\n> let it propagate to B2 e.g. through sync rep.\n> \n> So while you may be right in single-DC deployments, with multi-DC\n> deployments the situation is quite different - not only that the network\n> bandwidth is not unlimited, but because latencies within DC may be a\n> fraction of latencies between the locations (to the extent that the\n> increase due to syncrep may be just noise). So the local replication may\n> be actually way faster.\n\nI'm not seeing how the above is better using syncrep than using shard\ncopying?\n\n> I can imagine forwarding the data between B1 and B2 even with a purely\n> sharding solution, but at that point you effectively re-implemented\n> syncrep.\n\nNot really, the mechanism is different and the behavior is different.\nOne critical deficiency in using binary syncrep is that you can't do\nround-robin redundancy at all; every redundant node has to be an exact\nmirror of another node. In a good HA distributed system, you want\nmultiple shards per node, and you want each shard to be replicated to a\ndifferent node, so that in the event of node failure you're not dumping\nthe full load on one other server.\n\n> IMHO the design has to address the multi-DC setups somehow. I think that\n> many of the customers who are so concerned about scaling to many shards\n> are also concerned about availability in case of DC outages, no?\n\nCertainly. But users located in a single DC shouldn't pay the same\noverhead as users who are geographically spread.\n\n> I don't follow. With sync rep we do know whether the copy is OK or not,\n> because the node either confirms writes or not. The failover certainly\n> is more complicated and is not immediate (to the extent of keeping a\n> copy at the sharding level), but it's a question of trade-offs.\n> \n> It's true we don't have auto-failover solution at the moment, but as I\n> said - I can easily imagine most people using just sharding, while some\n> deployments use syncrep with manual failover.\n\nAs long as direct shard copying is available, I'm happy. I have no\ncomplaints about additional mechanisms.\n\nI'm bringing this up because the FDW proposal made at pgCon did not\ninclude *any* mechanism for HA/redundancy, just some handwaving about\nreplication and/or BDR. This was one of the critical design failures of\nPostgresXC. A multinode system without automated node failover and\nreplacement is a low-availability system.\n\n>> If we write to multiple copies as a part of the sharding feature,\n>> then that can be parallelized, so that we are waiting only as long as\n>> the slowest write (or in failure cases, as long as the shard\n>> timeout). Further, we can check for shard-copy health and update\n>> shard availability data with each user request, so that the ability\n>> to see stale/bad data is minimized.\n> \n> Again, this assumes infinite network bandwidth.\n\nIn what way is the total network bandwitdh used in the system different\nfor shard copying than for sync replication?\n\n-- \nJosh Berkus\nPostgreSQL Experts Inc.\nhttp://pgexperts.com\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 15:09:09 -0700","msg_from":"Josh Berkus <josh@agliodbs.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 12:40:40PM -0400, Robert Haas wrote:\n> On Tue, Sep 1, 2015 at 6:55 AM, Bruce Momjian <bruce@momjian.us> wrote:\n> > I assumed these queries were going to be solved by sending as digested\n> > data as possible to the coordinator, and having the coordinator complete\n> > any remaining processing. I think we are going to need to decide if\n> > such \"sending data back to shards\" is something we are ever going to\n> > implement. I can see FDWs _not_ working well for that use-case.\n> \n> I do think we are going to want to support that. All the people I've\n> talked to about parallel and distributed query processing agree that\n> you need to do that sort of thing to get really good and scalable\n> performance. I think that we could make a lot of headway as compared\n> with the status quo just by implementing more pushdown optimizations\n> than we have today. Right now, SELECT COUNT(*) FROM table will suck\n> back the whole remote table and count the rows locally, and that's\n> stupid. We can fix that case with better pushdown logic. We can also\n> fix the case of N-way join nests where the joins are either on the\n> partitioning key or to replicated tables. But suppose you have a join\n> between two tables which are sharded across the cluster but not on the\n> partitioning key. There's no way to push the join down, so all the\n> work comes back to the coordinator, which is possibly OK if such\n> queries are rare, but not so hot if they are frequent.\n\nLet me clearer about what the Citus Data paper shows. I said originally\nthat the data was sent to the coordinator, sorted, then resent to the\nshards, but the document:\n\n\thttps://goo.gl/vJWF85\n\thttps://www.citusdata.com/blog/114-how-to-build-your-distributed-database\n\nhas the shards create the groups and the groups are sent to the other\nshards. For example, to do COUNT(DISTINCT) if you have three shards,\nthen each shard breaks its data into 3 buckets (1B in size), then the\nfirst bucket from each of the three shards goes to the first shard, and\nthe second bucket goes to the second shared, etc.\n\nBasically, they are doing map-reduce, and the shards are creating\nadditional batches that get shipped to other shards. I can see FDWs not\nworking well in that case as you are really creating a new data layout\njust for the query. This explains why the XC/XL people are saying they\nwould use FDWs if they existed at the time they started development,\nwhile the Citus Data people are saying they couldn't use FDWs as they\ncurrently exist. They probably both needed FDW improvements, but I\nthink the Citus Data features would need a lot more.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 18:11:45 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 10:17 AM, Robert Haas <robertmhaas@gmail.com> wrote:\n> On Tue, Sep 1, 2015 at 1:06 PM, Josh Berkus <josh@agliodbs.com> wrote:\n>> You're assuming that our primary bottleneck for writes is IO. It's not\n>> at present for most users, and it certainly won't be in the future. You\n>> need to move your thinking on systems resources into the 21st century,\n>> instead of solving the resource problems from 15 years ago.\n>\n> Your experience doesn't match mine. I find that it's frequently\n> impossible to get the system to use all of the available CPU capacity,\n> either because you're bottlenecked on locks or because you are\n> bottlenecked on the I/O subsystem, and with the locking improvements\n> in newer versions, the former is becoming less and less common.\n\nI think you're both right. I think that we need to fix the buffer\nmanager, to make its caching algorithm smarter. Since we're mostly\nusing the filesystem cache, this is particularly important for\nPostgreSQL. We need to remember usage information for evicted blocks\nfor some period of time afterwards. This problem is largely a problem\nwith Postgres in particular, I suspect.\n\nAt the same time, I agree with Josh's assessment that long-term, we\nare going to have the biggest problem with memory latency and memory\nbandwidth, which are usually considered facets of CPU performance, and\nwith internal lock contention. Addressing the memory access bottleneck\ndovetails with parallelism, in that it must be considered alongside\nparallelism. Josh's \"21st century\" remark seems quite justified to me.\nFor a further example of this, check out my latest progress with\nexternal sorting, which I plan to post later in the week. I/O isn't\nthe big problem there at all, and I now think we can make external\nsorts close to internal sorts in performance across the board.\n\nI imagine that Josh's experience is based on workloads that mostly fit\nin shared_buffers, so I can see why you'd disagree if that was\nsomething you've seen less of. I'll quote Hellerstein and Stonebraker\nin 2007 [1]:\n\n\"Copying data in memory can be a serious bottleneck. Copies contribute\nlatency, consume CPU cycles, and can flood the CPU data. This fact is\noften a surprise to people who have not operated or implemented a\ndatabase system, and assume that main-memory operations are “free”\ncompared to disk I/O. But in practice, throughput in a well-tuned\ntransaction processing DBMS is typically not I/O-bound. This is\nachieved in high-end installations by purchasing sufficient disks and\nRAM so that repeated page requests are absorbed by the buffer pool,\nand disk I/Os are shared across the disk arms at a rate that can feed\nthe data appetite of all the processors in the system.\"\n\n>> Our real future bottlenecks are:\n>>\n>> * ability to handle more than a few hundred connections\n>> * locking limits on the scalability of writes\n>> * ability to manage large RAM and data caches\n>\n> I do agree that all of those things are problems, FWIW.\n\nThese seem like our long term problems, to me.\n\n[1] http://db.cs.berkeley.edu/papers/fntdb07-architecture.pdf, page 213\n-- \nPeter Geoghegan\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 1 Sep 2015 15:15:08 -0700","msg_from":"Peter Geoghegan <pg@heroku.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 2015-09-02 00:09, Josh Berkus wrote:\n> On 09/01/2015 02:29 PM, Tomas Vondra wrote:\n>> For example assume that there are just two shards in two separate data\n>> centers, connected by a link with limited bandwidth. Now, let's assume\n>> you always keep a local replica for failover. So you have A1+A2 in DC1,\n>> B1+B2 in DC2. If you're in DC1, then writing data to B1 means you also\n>> have to write data to B2 and wait for it. So either you send the data to\n>> each node separately (consuming 2x the bandwidth), or send it to B1 and\n>> let it propagate to B2 e.g. through sync rep.\n>>\n>> So while you may be right in single-DC deployments, with multi-DC\n>> deployments the situation is quite different - not only that the network\n>> bandwidth is not unlimited, but because latencies within DC may be a\n>> fraction of latencies between the locations (to the extent that the\n>> increase due to syncrep may be just noise). So the local replication may\n>> be actually way faster.\n>\n> I'm not seeing how the above is better using syncrep than using shard\n> copying?\n\nShard copying usually assumes that the origin node does the copy - the\ndata has to go twice through the slow connection. With replication you\ncan replicate locally over fast connection.\n\n>\n>> I can imagine forwarding the data between B1 and B2 even with a purely\n>> sharding solution, but at that point you effectively re-implemented\n>> syncrep.\n>\n> Not really, the mechanism is different and the behavior is different.\n> One critical deficiency in using binary syncrep is that you can't do\n> round-robin redundancy at all; every redundant node has to be an exact\n> mirror of another node. In a good HA distributed system, you want\n> multiple shards per node, and you want each shard to be replicated to a\n> different node, so that in the event of node failure you're not dumping\n> the full load on one other server.\n>\n\nThis assumes that we use binary replication, but we can reasonably use\nlogical replication which can quite easily do filtering of what's\nreplicated where.\n\n>> IMHO the design has to address the multi-DC setups somehow. I think that\n>> many of the customers who are so concerned about scaling to many shards\n>> are also concerned about availability in case of DC outages, no?\n>\n> Certainly. But users located in a single DC shouldn't pay the same\n> overhead as users who are geographically spread.\n>\n\nAgreed, so we should support both ways, but I don't think it's necessary\nto support both ways in version 0.1. It's just important to not paint\nourselves into a corner with design decisions that would make one of the\nways impossible.\n\n\n>>> If we write to multiple copies as a part of the sharding feature,\n>>> then that can be parallelized, so that we are waiting only as long as\n>>> the slowest write (or in failure cases, as long as the shard\n>>> timeout). Further, we can check for shard-copy health and update\n>>> shard availability data with each user request, so that the ability\n>>> to see stale/bad data is minimized.\n>>\n>> Again, this assumes infinite network bandwidth.\n>\n> In what way is the total network bandwitdh used in the system different\n> for shard copying than for sync replication?\n>\n\nAgain, when shards are distributed over multiple DCs (or actually even\nmultiple racks) the bandwidth and latency of local copy will be much\nbetter then the one of the remote copy so the local replication can have\nmuch lower impact on the cluster performance than remote shard copy will.\n\n-- \n Petr Jelinek http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 01:14:10 +0200","msg_from":"Petr Jelinek <petr@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"> On Tue, Sep 1, 2015 at 9:48 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n> >\n> > On Tue, Sep 1, 2015 at 4:15 AM, Andres Freund <andres@anarazel.de>\nwrote:\n> > > On 2015-08-31 20:54:51 -0400, Bruce Momjian wrote:\n> > >> Uh, we already have a list of things we need to add to FDWs to make\nthem\n> > >> work, and Citus Data has provided a document of more things that are\n> > >> needed, https://goo.gl/vJWF85. I am not sure how much bigger a red\nflag\n> > >> you want to confirm that everyone agrees that major FDW improvements\nare\n> > >> a requirement for this.\n> > >\n> > > Several people saying that the FDW infrastructure isn't sufficient\nright\n> > > now is pretty far from implying that all of them agree that the FDW\nAPI\n> > > is the way to go.\n> > >\n> > > I'm not sure myself. If it works out it's going to save us some work\nand\n> > > make it more realistic to get there sometime not too far off. But I'm\n> > > afraid that the resulting system will feel like our current\npartitioning\n> > > implemenentation. Yes, it kinda works, but it's hard to get started,\nit\n> > > doesn't support too many features and you're kind afraid your\nrelatives\n> > > will see what you've done.\n> >\n> > I'm not averse to making the \"connect to the remote nodes\" part of\n> > this solution use something other than the FDW infrastructure at some\n> > point in time if somebody's prepared to build something better. On\n> > the other hand, I think it's extremely clear that the FDW\n> > infrastructure has a large amount of potential upon which we have\n> > thoroughly failed to capitalize. Patches have already been written\n> > for UPDATE/DELETE pushdown and for join pushdown.\n\nWill pushing down writes (Update/Delete) sufficient to maintain sane locking\nbehaviour and deadlock detection that can occur during writes on multiple\nshards? For example it could easily be the case where a single Update\nstatement could effect multiple shards and cause deadlock due to waits\nacross the nodes. Now unless we have some distributed lock manager or\nsome other way to know the information of locks that happens across\nshards, it could be difficult to detect deadlocks.\n\n\nWith Regards,\nAmit Kapila.\nEnterpriseDB: http://www.enterprisedb.com\n\n> On Tue, Sep 1, 2015 at 9:48 PM, Robert Haas <robertmhaas@gmail.com> wrote:> >> > On Tue, Sep 1, 2015 at 4:15 AM, Andres Freund <andres@anarazel.de> wrote:> > > On 2015-08-31 20:54:51 -0400, Bruce Momjian wrote:> > >> Uh, we already have a list of things we need to add to FDWs to make them> > >> work, and Citus Data has provided a document of more things that are> > >> needed, https://goo.gl/vJWF85. I am not sure how much bigger a red flag> > >> you want to confirm that everyone agrees that major FDW improvements are> > >> a requirement for this.> > >> > > Several people saying that the FDW infrastructure isn't sufficient right> > > now is pretty far from implying that all of them agree that the FDW API> > > is the way to go.> > >> > > I'm not sure myself. If it works out it's going to save us some work and> > > make it more realistic to get there sometime not too far off. But I'm> > > afraid that the resulting system will feel like our current partitioning> > > implemenentation. Yes, it kinda works, but it's hard to get started, it> > > doesn't support too many features and you're kind afraid your relatives> > > will see what you've done.> >> > I'm not averse to making the \"connect to the remote nodes\" part of> > this solution use something other than the FDW infrastructure at some> > point in time if somebody's prepared to build something better. On> > the other hand, I think it's extremely clear that the FDW> > infrastructure has a large amount of potential upon which we have> > thoroughly failed to capitalize. Patches have already been written> > for UPDATE/DELETE pushdown and for join pushdown.Will pushing down writes (Update/Delete) sufficient to maintain sane lockingbehaviour and deadlock detection that can occur during writes on multipleshards? For example it could easily be the case where a single Updatestatement could effect multiple shards and cause deadlock due to waitsacross the nodes. Now unless we have some distributed lock manager orsome other way to know the information of locks that happens acrossshards, it could be difficult to detect deadlocks.With Regards,Amit Kapila.EnterpriseDB: http://www.enterprisedb.com","msg_date":"Wed, 2 Sep 2015 09:58:00 +0530","msg_from":"Amit Kapila <amit.kapila16@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 4:25 PM, Bruce Momjian <bruce@momjian.us> wrote:\n>\n>\n> The document opens a big question --- when queries can't be processed in\n> a traditional top/down fashion, Citus has the goal of sending groups of\n> results up the the coordinator, reordering them, then sending them back\n> to the shards for further processing, basically using the shards as\n> compute engines because the shards are no longer using local data to do\n> their computations. The two examples they give are COUNT(DISTINCT) and\n> a join across two sharded tables (\"CANADA\").\n>\n> I assumed these queries were going to be solved by sending as digested\n> data as possible to the coordinator, and having the coordinator complete\n> any remaining processing. I think we are going to need to decide if\n> such \"sending data back to shards\" is something we are ever going to\n> implement. I can see FDWs _not_ working well for that use-case.\n>\n\nHere one related point to think is how do we envision to handle statement\nrequests, do we want to have centeralized coordinator which will process\nall requests or the requests could be received by any node?\nI think both kind of systems have their own pros and cons like if we want\nto have centralized coordinator kind of system, then it might be limited\nby the number of simultaneous requests it can handle and if go other way\nlike allow requests to be processed by each individual nodes, then we\nhave to think about replicating all meta-data on all nodes.\n\nI think Collecting statistics about different objects is another thing which\ncan differ depending on the strategy we choose to allow requests.\n\n\nWith Regards,\nAmit Kapila.\nEnterpriseDB: http://www.enterprisedb.com\n\nOn Tue, Sep 1, 2015 at 4:25 PM, Bruce Momjian <bruce@momjian.us> wrote:>>> The document opens a big question --- when queries can't be processed in> a traditional top/down fashion, Citus has the goal of sending groups of> results up the the coordinator, reordering them, then sending them back> to the shards for further processing, basically using the shards as> compute engines because the shards are no longer using local data to do> their computations. The two examples they give are COUNT(DISTINCT) and> a join across two sharded tables (\"CANADA\").>> I assumed these queries were going to be solved by sending as digested> data as possible to the coordinator, and having the coordinator complete> any remaining processing. I think we are going to need to decide if> such \"sending data back to shards\" is something we are ever going to> implement. I can see FDWs _not_ working well for that use-case.>Here one related point to think is how do we envision to handle statementrequests, do we want to have centeralized coordinator which will processall requests or the requests could be received by any node?I think both kind of systems have their own pros and cons like if we wantto have centralized coordinator kind of system, then it might be limitedby the number of simultaneous requests it can handle and if go other waylike allow requests to be processed by each individual nodes, then wehave to think about replicating all meta-data on all nodes.I think Collecting statistics about different objects is another thing whichcan differ depending on the strategy we choose to allow requests.With Regards,Amit Kapila.EnterpriseDB: http://www.enterprisedb.com","msg_date":"Wed, 2 Sep 2015 10:07:00 +0530","msg_from":"Amit Kapila <amit.kapila16@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 2015-09-02 PM 01:28, Amit Kapila wrote:\n>> On Tue, Sep 1, 2015 at 9:48 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>>>\n>>> I'm not averse to making the \"connect to the remote nodes\" part of\n>>> this solution use something other than the FDW infrastructure at some\n>>> point in time if somebody's prepared to build something better. On\n>>> the other hand, I think it's extremely clear that the FDW\n>>> infrastructure has a large amount of potential upon which we have\n>>> thoroughly failed to capitalize. Patches have already been written\n>>> for UPDATE/DELETE pushdown and for join pushdown.\n> \n> Will pushing down writes (Update/Delete) sufficient to maintain sane locking\n> behaviour and deadlock detection that can occur during writes on multiple\n> shards? For example it could easily be the case where a single Update\n> statement could effect multiple shards and cause deadlock due to waits\n> across the nodes. Now unless we have some distributed lock manager or\n> some other way to know the information of locks that happens across\n> shards, it could be difficult to detect deadlocks.\n> \n\nI wonder if Ashutosh's atomic foreign transactions patch would address any\nissues inherent in such cases...\n\nThanks,\nAmit\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 14:28:44 +0900","msg_from":"Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 2015/09/02 14:28, Amit Langote wrote:\n> On 2015-09-02 PM 01:28, Amit Kapila wrote:\n>>> On Tue, Sep 1, 2015 at 9:48 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>>>> I'm not averse to making the \"connect to the remote nodes\" part of\n>>>> this solution use something other than the FDW infrastructure at some\n>>>> point in time if somebody's prepared to build something better. On\n>>>> the other hand, I think it's extremely clear that the FDW\n>>>> infrastructure has a large amount of potential upon which we have\n>>>> thoroughly failed to capitalize. Patches have already been written\n>>>> for UPDATE/DELETE pushdown and for join pushdown.\n\n>> Will pushing down writes (Update/Delete) sufficient to maintain sane locking\n>> behaviour and deadlock detection that can occur during writes on multiple\n>> shards? For example it could easily be the case where a single Update\n>> statement could effect multiple shards and cause deadlock due to waits\n>> across the nodes. Now unless we have some distributed lock manager or\n>> some other way to know the information of locks that happens across\n>> shards, it could be difficult to detect deadlocks.\n\n> I wonder if Ashutosh's atomic foreign transactions patch would address any\n> issues inherent in such cases...\n\nThe UPDATE/DELETE pushdown, which I've proposed, would ensure the sane \nbehaviour for inherited UPDATEs/DELETEs, as existing non-pushed-down \nUPDATE/DELETE does, because inheritance_planner guarantees that all \nbackends lock inheritance children in the same order to avoid needless \ndeadlocks.\n\nBest regards,\nEtsuro Fujita\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 02 Sep 2015 15:05:22 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Wed, Sep 2, 2015 at 11:35 AM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\nwrote:\n\n> On 2015/09/02 14:28, Amit Langote wrote:\n>\n>> On 2015-09-02 PM 01:28, Amit Kapila wrote:\n>>\n>>> On Tue, Sep 1, 2015 at 9:48 PM, Robert Haas <robertmhaas@gmail.com>\n>>>> wrote:\n>>>>\n>>>>> I'm not averse to making the \"connect to the remote nodes\" part of\n>>>>> this solution use something other than the FDW infrastructure at some\n>>>>> point in time if somebody's prepared to build something better. On\n>>>>> the other hand, I think it's extremely clear that the FDW\n>>>>> infrastructure has a large amount of potential upon which we have\n>>>>> thoroughly failed to capitalize. Patches have already been written\n>>>>> for UPDATE/DELETE pushdown and for join pushdown.\n>>>>>\n>>>>\n> Will pushing down writes (Update/Delete) sufficient to maintain sane\n>>> locking\n>>> behaviour and deadlock detection that can occur during writes on multiple\n>>> shards? For example it could easily be the case where a single Update\n>>> statement could effect multiple shards and cause deadlock due to waits\n>>> across the nodes. Now unless we have some distributed lock manager or\n>>> some other way to know the information of locks that happens across\n>>> shards, it could be difficult to detect deadlocks.\n>>>\n>>\n> I wonder if Ashutosh's atomic foreign transactions patch would address any\n>> issues inherent in such cases...\n>>\n>\n> The UPDATE/DELETE pushdown, which I've proposed, would ensure the sane\n> behaviour for inherited UPDATEs/DELETEs, as existing non-pushed-down\n> UPDATE/DELETE does, because inheritance_planner guarantees that all\n> backends lock inheritance children in the same order to avoid needless\n> deadlocks.\n>\n>\nWill it be able to do it for row level locks, row level locking occurs\nduring updation of a row, so will it be possible to ensure the order of\nlocks on rows?\n\nWill it handle deadlocks across different table partitions. Consider\na case as below:\n\nT1\n1. Updates row R1 of T1 on shard S1\n2. Updates row R2 of T2 on shard S2\n\nT2\n1. Updates row R2 of T2 on shard S2\n2. Updates row R1 of T1 on shard S1\n\n\n\nWith Regards,\nAmit Kapila.\nEnterpriseDB: http://www.enterprisedb.com\n\nOn Wed, Sep 2, 2015 at 11:35 AM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp> wrote:On 2015/09/02 14:28, Amit Langote wrote:\n\nOn 2015-09-02 PM 01:28, Amit Kapila wrote:\n\nOn Tue, Sep 1, 2015 at 9:48 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n\nI'm not averse to making the \"connect to the remote nodes\" part of\nthis solution use something other than the FDW infrastructure at some\npoint in time if somebody's prepared to build something better. On\nthe other hand, I think it's extremely clear that the FDW\ninfrastructure has a large amount of potential upon which we have\nthoroughly failed to capitalize. Patches have already been written\nfor UPDATE/DELETE pushdown and for join pushdown.\n\n\n\nWill pushing down writes (Update/Delete) sufficient to maintain sane locking\nbehaviour and deadlock detection that can occur during writes on multiple\nshards? For example it could easily be the case where a single Update\nstatement could effect multiple shards and cause deadlock due to waits\nacross the nodes. Now unless we have some distributed lock manager or\nsome other way to know the information of locks that happens across\nshards, it could be difficult to detect deadlocks.\n\n\n\nI wonder if Ashutosh's atomic foreign transactions patch would address any\nissues inherent in such cases...\n\n\nThe UPDATE/DELETE pushdown, which I've proposed, would ensure the sane behaviour for inherited UPDATEs/DELETEs, as existing non-pushed-down UPDATE/DELETE does, because inheritance_planner guarantees that all backends lock inheritance children in the same order to avoid needless deadlocks.\nWill it be able to do it for row level locks, row level locking occursduring updation of a row, so will it be possible to ensure the order oflocks on rows?Will it handle deadlocks across different table partitions. Considera case as below:T11. Updates row R1 of T1 on shard S12. Updates row R2 of T2 on shard S2T21. Updates row R2 of T2 on shard S2 2. Updates row R1 of T1 on shard S1With Regards,Amit Kapila.EnterpriseDB: http://www.enterprisedb.com","msg_date":"Wed, 2 Sep 2015 11:55:38 +0530","msg_from":"Amit Kapila <amit.kapila16@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 2015-09-02 PM 03:25, Amit Kapila wrote:\n> On Wed, Sep 2, 2015 at 11:35 AM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\n>>\n>> The UPDATE/DELETE pushdown, which I've proposed, would ensure the sane\n>> behaviour for inherited UPDATEs/DELETEs, as existing non-pushed-down\n>> UPDATE/DELETE does, because inheritance_planner guarantees that all\n>> backends lock inheritance children in the same order to avoid needless\n>> deadlocks.\n>>\n>>\n> Will it be able to do it for row level locks, row level locking occurs\n> during updation of a row, so will it be possible to ensure the order of\n> locks on rows?\n> \n> Will it handle deadlocks across different table partitions. Consider\n> a case as below:\n> \n> T1\n> 1. Updates row R1 of T1 on shard S1\n> 2. Updates row R2 of T2 on shard S2\n> \n> T2\n> 1. Updates row R2 of T2 on shard S2\n> 2. Updates row R1 of T1 on shard S1\n> \n\nAs long as shards are processed in the same order in different\ntransactions, ISTM, this issue should not arise? I can imagine it becoming\na concern if parallel shard processing enters the scene. Am I missing\nsomething?\n\nThanks,\nAmit\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 15:40:40 +0900","msg_from":"Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 2015/09/02 15:40, Amit Langote wrote:\n> On 2015-09-02 PM 03:25, Amit Kapila wrote:\n>> On Wed, Sep 2, 2015 at 11:35 AM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\n>>> The UPDATE/DELETE pushdown, which I've proposed, would ensure the sane\n>>> behaviour for inherited UPDATEs/DELETEs, as existing non-pushed-down\n>>> UPDATE/DELETE does, because inheritance_planner guarantees that all\n>>> backends lock inheritance children in the same order to avoid needless\n>>> deadlocks.\n\n>> Will it be able to do it for row level locks, row level locking occurs\n>> during updation of a row, so will it be possible to ensure the order of\n>> locks on rows?\n\n>> Will it handle deadlocks across different table partitions. Consider\n>> a case as below:\n>>\n>> T1\n>> 1. Updates row R1 of T1 on shard S1\n>> 2. Updates row R2 of T2 on shard S2\n>>\n>> T2\n>> 1. Updates row R2 of T2 on shard S2\n>> 2. Updates row R1 of T1 on shard S1\n\n> As long as shards are processed in the same order in different\n> transactions, ISTM, this issue should not arise? I can imagine it becoming\n> a concern if parallel shard processing enters the scene. Am I missing\n> something?\n\nYeah, I thinks so, too.\n\nSorry, maybe my explanation above was not enough, but in the inherted \nUPDATEs/DELETEs, the table modification is also ensured to be done in \nthe same order. So, as Amit Langote said, both transactions will do the \nupdates in the same order.\n\nBest regards,\nEtsuro Fujita\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 02 Sep 2015 15:59:42 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"Amit Langote wrote:\r\n> On 2015-09-02 PM 03:25, Amit Kapila wrote:\r\n>> Will it handle deadlocks across different table partitions. Consider\r\n>> a case as below:\r\n>>\r\n>> T1\r\n>> 1. Updates row R1 of T1 on shard S1\r\n>> 2. Updates row R2 of T2 on shard S2\r\n>>\r\n>> T2\r\n>> 1. Updates row R2 of T2 on shard S2\r\n>> 2. Updates row R1 of T1 on shard S1\r\n\r\n> As long as shards are processed in the same order in different\r\n> transactions, ISTM, this issue should not arise? I can imagine it becoming\r\n> a concern if parallel shard processing enters the scene. Am I missing\r\n> something?\r\n\r\nThat would only hold for a single query, right?\r\n\r\nIf 1. and 2. in the above example come from different queries within one\r\ntransaction, you cannot guarantee that shards are processed in the same order.\r\n\r\nSo T1 and T2 could deadlock.\r\n\r\nYours,\r\nLaurenz Albe\r\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 07:07:56 +0000","msg_from":"Albe Laurenz <laurenz.albe@wien.gv.at>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 2015-09-02 PM 04:07, Albe Laurenz wrote:\n> Amit Langote wrote:\n>> On 2015-09-02 PM 03:25, Amit Kapila wrote:\n>>> Will it handle deadlocks across different table partitions. Consider\n>>> a case as below:\n>>>\n>>> T1\n>>> 1. Updates row R1 of T1 on shard S1\n>>> 2. Updates row R2 of T2 on shard S2\n>>>\n>>> T2\n>>> 1. Updates row R2 of T2 on shard S2\n>>> 2. Updates row R1 of T1 on shard S1\n> \n>> As long as shards are processed in the same order in different\n>> transactions, ISTM, this issue should not arise? I can imagine it becoming\n>> a concern if parallel shard processing enters the scene. Am I missing\n>> something?\n> \n> That would only hold for a single query, right?\n> \n> If 1. and 2. in the above example come from different queries within one\n> transaction, you cannot guarantee that shards are processed in the same order.\n> \n> So T1 and T2 could deadlock.\n> \n\nSorry, I failed to see why that would be the case. Could you elaborate?\n\nThanks,\nAmit\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 16:40:37 +0900","msg_from":"Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 2015/09/02 16:40, Amit Langote wrote:\n> On 2015-09-02 PM 04:07, Albe Laurenz wrote:\n>> Amit Langote wrote:\n>>> On 2015-09-02 PM 03:25, Amit Kapila wrote:\n>>>> Will it handle deadlocks across different table partitions. Consider\n>>>> a case as below:\n>>>>\n>>>> T1\n>>>> 1. Updates row R1 of T1 on shard S1\n>>>> 2. Updates row R2 of T2 on shard S2\n>>>>\n>>>> T2\n>>>> 1. Updates row R2 of T2 on shard S2\n>>>> 2. Updates row R1 of T1 on shard S1\n>>\n>>> As long as shards are processed in the same order in different\n>>> transactions, ISTM, this issue should not arise? I can imagine it becoming\n>>> a concern if parallel shard processing enters the scene. Am I missing\n>>> something?\n>>\n>> That would only hold for a single query, right?\n>>\n>> If 1. and 2. in the above example come from different queries within one\n>> transaction, you cannot guarantee that shards are processed in the same order.\n>>\n>> So T1 and T2 could deadlock.\n\n> Sorry, I failed to see why that would be the case. Could you elaborate?\n\nI think Laurenz would assume that the updates 1. and 2. in the above \ntransactions are performed *in a non-inherited manner*. If that's \nright, T1 and T2 could deadlock, but I think we assume here to run \ntransactions over shards *in an inherited manner*.\n\nBest regards,\nEtsuro Fujita\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 02 Sep 2015 17:07:23 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"Etsuro Fujita wrote:\r\n> On 2015/09/02 16:40, Amit Langote wrote:\r\n>> On 2015-09-02 PM 04:07, Albe Laurenz wrote:\r\n>>> Amit Langote wrote:\r\n>>>> On 2015-09-02 PM 03:25, Amit Kapila wrote:\r\n>>>>> Will it handle deadlocks across different table partitions. Consider\r\n>>>>> a case as below:\r\n>>>>>\r\n>>>>> T1\r\n>>>>> 1. Updates row R1 of T1 on shard S1\r\n>>>>> 2. Updates row R2 of T2 on shard S2\r\n>>>>>\r\n>>>>> T2\r\n>>>>> 1. Updates row R2 of T2 on shard S2\r\n>>>>> 2. Updates row R1 of T1 on shard S1\r\n>>>\r\n>>>> As long as shards are processed in the same order in different\r\n>>>> transactions, ISTM, this issue should not arise? I can imagine it becoming\r\n>>>> a concern if parallel shard processing enters the scene. Am I missing\r\n>>>> something?\r\n>>>\r\n>>> That would only hold for a single query, right?\r\n>>>\r\n>>> If 1. and 2. in the above example come from different queries within one\r\n>>> transaction, you cannot guarantee that shards are processed in the same order.\r\n>>>\r\n>>> So T1 and T2 could deadlock.\r\n> \r\n>> Sorry, I failed to see why that would be the case. Could you elaborate?\r\n> \r\n> I think Laurenz would assume that the updates 1. and 2. in the above\r\n> transactions are performed *in a non-inherited manner*. If that's\r\n> right, T1 and T2 could deadlock, but I think we assume here to run\r\n> transactions over shards *in an inherited manner*.\r\n\r\nYes, but does every update affect all shards?\r\n\r\nIf I say \"UPDATE t1 SET col = 1 WHERE id = 42\" and the row with id 42\r\nhappens to be on shard S1, the update would only affect that shard, right?\r\n\r\nNow if \"UPDATE t2 SET col = 1 WHERE id = 42\" would only take place on\r\nshard S2, and two transactions issue both updates in different order,\r\none transaction would be waiting for a lock on shard S1, while the other\r\nwould be waiting for a lock on shard S2, right?\r\n\r\nBut maybe I'm missing something fundamental.\r\n\r\nYours,\r\nLaurenz Albe\r\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 08:58:02 +0000","msg_from":"Albe Laurenz <laurenz.albe@wien.gv.at>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 2015-09-02 PM 05:07, Etsuro Fujita wrote:\n> On 2015/09/02 16:40, Amit Langote wrote:\n>> On 2015-09-02 PM 04:07, Albe Laurenz wrote:\n>>>\n>>> That would only hold for a single query, right?\n>>>\n>>> If 1. and 2. in the above example come from different queries within one\n>>> transaction, you cannot guarantee that shards are processed in the same\n>>> order.\n>>>\n>>> So T1 and T2 could deadlock.\n> \n>> Sorry, I failed to see why that would be the case. Could you elaborate?\n> \n> I think Laurenz would assume that the updates 1. and 2. in the above\n> transactions are performed *in a non-inherited manner*. If that's right,\n> T1 and T2 could deadlock, but I think we assume here to run transactions\n> over shards *in an inherited manner*.\n> \n\nI think Albe may have a point here...\n\nEven inherited updates case appears to cause a deadlock if they are in\ndifferent queries. Demonstrated below:\n\n-- setup\nCREATE TABLE t(a int);\nCREATE TABLE t1() INHERITS(t);\nCREATE TABLE t2() INHERITS(t);\n\nINSERT INTO t1 VALUES (1);\nINSERT INTO t2 VALUES (2);\n\n-- in session 1\nBEGIN;\nUPDATE t SET a = a + 1 WHERE a = 1;\n<ok>\n\n-- in session 2\nBEGIN;\nUPDATE t SET a = a + 1 WHERE a = 2;\n<ok>\n\n-- back in session 1\nUPDATE t SET a = a + 1 WHERE a = 2;\n<waits>\n\n-- back in session 2\nUPDATE t SET a = a + 1 WHERE a = 1;\n<deadlock is detected>\n\n\nThanks,\nAmit\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 18:41:13 +0900","msg_from":"Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Wed, Sep 2, 2015 at 12:49 AM, Josh Berkus <josh@agliodbs.com> wrote:\n\n> On 09/01/2015 11:36 AM, Tomas Vondra wrote:\n> >> We want multiple copies of shards created by the sharding system itself.\n> >> Having a separate, and completely orthagonal, redundancy system to the\n> >> sharding system is overly burdensome on the DBA and makes low-data-loss\n> >> HA impossible.\n> >\n> > IMHO it'd be quite unfortunate if the design would make it impossible to\n> > combine those two features (e.g. creating standbys for shards and\n> > failing over to them).\n> >\n> > It's true that solving HA at the sharding level (by keeping multiple\n> > copies of a each shard) may be simpler than combining sharding and\n> > standbys, but I don't see why it makes low-data-loss HA impossible.\n>\n> Other way around, that is, having replication standbys as the only\n> method of redundancy requires either high data loss or high latency for\n> all writes.\n>\n> In the case of async rep, every time we fail over a node, the entire\n> cluser would need to roll back to the last common known-good replay\n> point, hence high data loss.\n>\n> In the case of sync rep, we are required to wait for at least double\n> network lag time in order to do a single write ... making\n> write-scalability quite difficult.\n>\n> Futher, if using replication the sharding system would have no way to\n> (a) find out immediately if a copy was bad and (b) fail over quickly to\n> a copy of the shard if the first requested copy was not responding.\n> With async replication, we also can't use multiple copies of the same\n> shard as a way to balance read workloads.\n>\n> If we write to multiple copies as a part of the sharding feature, then\n> that can be parallelized, so that we are waiting only as long as the\n> slowest write (or in failure cases, as long as the shard timeout).\n> Further, we can check for shard-copy health and update shard\n> availability data with each user request, so that the ability to see\n> stale/bad data is minimized.\n>\n\nXC (and I guess XL, pgPool II as well) did this by firing same DML\nstatement to all the copies after resolving any volatile references (e.g.\nnow()) in DML, so that all the copies get the same values. That method\nhowever needed some row identifier which can identify same row on all the\nreplicas. Primary key is used as row identifier usually, but not all use\ncases which require shards to be replicated have primary key in their\nsharded tables.\n\n\n>\n> There are obvious problems with multiplexing writes, which you can\n> figure out if you knock pg_shard around a bit. But I really think that\n> solving those problems is the only way to go.\n>\n> Mind you, I see a strong place for binary replication and BDR for\n> multi-region redundancy; you really don't want that to be part of the\n> sharding system if you're aiming for write scalability.\n>\n> --\n> Josh Berkus\n> PostgreSQL Experts Inc.\n> http://pgexperts.com\n>\n>\n> --\n> Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\n> To make changes to your subscription:\n> http://www.postgresql.org/mailpref/pgsql-hackers\n>\n\n\n\n-- \nBest Wishes,\nAshutosh Bapat\nEnterpriseDB Corporation\nThe Postgres Database Company\n\nOn Wed, Sep 2, 2015 at 12:49 AM, Josh Berkus <josh@agliodbs.com> wrote:On 09/01/2015 11:36 AM, Tomas Vondra wrote:\n>> We want multiple copies of shards created by the sharding system itself.\n>> Having a separate, and completely orthagonal, redundancy system to the\n>> sharding system is overly burdensome on the DBA and makes low-data-loss\n>> HA impossible.\n>\n> IMHO it'd be quite unfortunate if the design would make it impossible to\n> combine those two features (e.g. creating standbys for shards and\n> failing over to them).\n>\n> It's true that solving HA at the sharding level (by keeping multiple\n> copies of a each shard) may be simpler than combining sharding and\n> standbys, but I don't see why it makes low-data-loss HA impossible.\n\nOther way around, that is, having replication standbys as the only\nmethod of redundancy requires either high data loss or high latency for\nall writes.\n\nIn the case of async rep, every time we fail over a node, the entire\ncluser would need to roll back to the last common known-good replay\npoint, hence high data loss.\n\nIn the case of sync rep, we are required to wait for at least double\nnetwork lag time in order to do a single write ... making\nwrite-scalability quite difficult.\n\nFuther, if using replication the sharding system would have no way to\n(a) find out immediately if a copy was bad and (b) fail over quickly to\na copy of the shard if the first requested copy was not responding.\nWith async replication, we also can't use multiple copies of the same\nshard as a way to balance read workloads.\n\nIf we write to multiple copies as a part of the sharding feature, then\nthat can be parallelized, so that we are waiting only as long as the\nslowest write (or in failure cases, as long as the shard timeout).\nFurther, we can check for shard-copy health and update shard\navailability data with each user request, so that the ability to see\nstale/bad data is minimized.XC (and I guess XL, pgPool II as well) did this by firing same DML statement to all the copies after resolving any volatile references (e.g. now()) in DML, so that all the copies get the same values. That method however needed some row identifier which can identify same row on all the replicas. Primary key is used as row identifier usually, but not all use cases which require shards to be replicated have primary key in their sharded tables. \n\nThere are obvious problems with multiplexing writes, which you can\nfigure out if you knock pg_shard around a bit. But I really think that\nsolving those problems is the only way to go.\n\nMind you, I see a strong place for binary replication and BDR for\nmulti-region redundancy; you really don't want that to be part of the\nsharding system if you're aiming for write scalability.\n\n--\nJosh Berkus\nPostgreSQL Experts Inc.\nhttp://pgexperts.com\n\n\n--\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n-- Best Wishes,Ashutosh BapatEnterpriseDB CorporationThe Postgres Database Company","msg_date":"Wed, 2 Sep 2015 15:49:29 +0530","msg_from":"Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 2015-09-02 PM 06:41, Amit Langote wrote:\n> \n> I think Albe may have a point here...\n> \n> Even inherited updates case appears to cause a deadlock if they are in\n> different queries. Demonstrated below:\n> \n> -- setup\n> CREATE TABLE t(a int);\n> CREATE TABLE t1() INHERITS(t);\n> CREATE TABLE t2() INHERITS(t);\n> \n> INSERT INTO t1 VALUES (1);\n> INSERT INTO t2 VALUES (2);\n> \n> -- in session 1\n> BEGIN;\n> UPDATE t SET a = a + 1 WHERE a = 1;\n> <ok>\n> \n> -- in session 2\n> BEGIN;\n> UPDATE t SET a = a + 1 WHERE a = 2;\n> <ok>\n> \n> -- back in session 1\n> UPDATE t SET a = a + 1 WHERE a = 2;\n> <waits>\n> \n> -- back in session 2\n> UPDATE t SET a = a + 1 WHERE a = 1;\n> <deadlock is detected>\n> \n\nWhich, I now realize, is not the worry Amit Kapila's expresses.\n\nThe deadlock was *indeed detected* in this case, with all the locks in the\nsame PG instance. In a sharded environment with multiple PG instances,\nthat becomes tricky. DLM (distributed lock manager/deadlock detector)\nseems indeed necessary as Amit K. suspects.\n\nThanks,\nAmit\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 19:25:21 +0900","msg_from":"Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Wed, Sep 2, 2015 at 3:55 PM, Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>\nwrote:\n\n> On 2015-09-02 PM 06:41, Amit Langote wrote:\n> >\n> > I think Albe may have a point here...\n> >\n> > Even inherited updates case appears to cause a deadlock if they are in\n> > different queries. Demonstrated below:\n> >\n> > -- setup\n> > CREATE TABLE t(a int);\n> > CREATE TABLE t1() INHERITS(t);\n> > CREATE TABLE t2() INHERITS(t);\n> >\n> > INSERT INTO t1 VALUES (1);\n> > INSERT INTO t2 VALUES (2);\n> >\n> > -- in session 1\n> > BEGIN;\n> > UPDATE t SET a = a + 1 WHERE a = 1;\n> > <ok>\n> >\n> > -- in session 2\n> > BEGIN;\n> > UPDATE t SET a = a + 1 WHERE a = 2;\n> > <ok>\n> >\n> > -- back in session 1\n> > UPDATE t SET a = a + 1 WHERE a = 2;\n> > <waits>\n> >\n> > -- back in session 2\n> > UPDATE t SET a = a + 1 WHERE a = 1;\n> > <deadlock is detected>\n> >\n>\n> Which, I now realize, is not the worry Amit Kapila's expresses.\n>\n> The deadlock was *indeed detected* in this case, with all the locks in the\n> same PG instance. In a sharded environment with multiple PG instances,\n> that becomes tricky. DLM (distributed lock manager/deadlock detector)\n> seems indeed necessary as Amit K. suspects.\n>\n>\nRight. XC/XL did not address this issue and they rely on statement timeouts\nto break distributed deadlocks.\n\nThanks,\nPavan\n\n-- \n Pavan Deolasee http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\nOn Wed, Sep 2, 2015 at 3:55 PM, Amit Langote <Langote_Amit_f8@lab.ntt.co.jp> wrote:On 2015-09-02 PM 06:41, Amit Langote wrote:\n>\n> I think Albe may have a point here...\n>\n> Even inherited updates case appears to cause a deadlock if they are in\n> different queries. Demonstrated below:\n>\n> -- setup\n> CREATE TABLE t(a int);\n> CREATE TABLE t1() INHERITS(t);\n> CREATE TABLE t2() INHERITS(t);\n>\n> INSERT INTO t1 VALUES (1);\n> INSERT INTO t2 VALUES (2);\n>\n> -- in session 1\n> BEGIN;\n> UPDATE t SET a = a + 1 WHERE a = 1;\n> <ok>\n>\n> -- in session 2\n> BEGIN;\n> UPDATE t SET a = a + 1 WHERE a = 2;\n> <ok>\n>\n> -- back in session 1\n> UPDATE t SET a = a + 1 WHERE a = 2;\n> <waits>\n>\n> -- back in session 2\n> UPDATE t SET a = a + 1 WHERE a = 1;\n> <deadlock is detected>\n>\n\nWhich, I now realize, is not the worry Amit Kapila's expresses.\n\nThe deadlock was *indeed detected* in this case, with all the locks in the\nsame PG instance. In a sharded environment with multiple PG instances,\nthat becomes tricky. DLM (distributed lock manager/deadlock detector)\nseems indeed necessary as Amit K. suspects.\nRight. XC/XL did not address this issue and they rely on statement timeouts to break distributed deadlocks.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services","msg_date":"Wed, 2 Sep 2015 16:19:07 +0530","msg_from":"Pavan Deolasee <pavan.deolasee@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Wed, Sep 2, 2015 at 4:19 PM, Pavan Deolasee <pavan.deolasee@gmail.com>\nwrote:\n> On Wed, Sep 2, 2015 at 3:55 PM, Amit Langote <\nLangote_Amit_f8@lab.ntt.co.jp> wrote:\n>>\n>> On 2015-09-02 PM 06:41, Amit Langote wrote:\n>>\n>> Which, I now realize, is not the worry Amit Kapila's expresses.\n>>\n>> The deadlock was *indeed detected* in this case, with all the locks in\nthe\n>> same PG instance. In a sharded environment with multiple PG instances,\n>> that becomes tricky. DLM (distributed lock manager/deadlock detector)\n>> seems indeed necessary as Amit K. suspects.\n>>\n>\n> Right. XC/XL did not address this issue and they rely on statement\ntimeouts to break distributed deadlocks.\n>\n\nI think that will be difficult for application to decide and then it\nneeds to decide the same for all statements which is tricky because\ndifferent statements could take different time. I think it is better to\nhave solution for this problem and deadlock should be detected.\n\n\nWith Regards,\nAmit Kapila.\nEnterpriseDB: http://www.enterprisedb.com\n\nOn Wed, Sep 2, 2015 at 4:19 PM, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:> On Wed, Sep 2, 2015 at 3:55 PM, Amit Langote <Langote_Amit_f8@lab.ntt.co.jp> wrote:>>>> On 2015-09-02 PM 06:41, Amit Langote wrote:>>>> Which, I now realize, is not the worry Amit Kapila's expresses.>>>> The deadlock was *indeed detected* in this case, with all the locks in the>> same PG instance. In a sharded environment with multiple PG instances,>> that becomes tricky. DLM (distributed lock manager/deadlock detector)>> seems indeed necessary as Amit K. suspects.>>>> Right. XC/XL did not address this issue and they rely on statement timeouts to break distributed deadlocks.>I think that will be difficult for application to decide and then itneeds to decide the same for all statements which is tricky becausedifferent statements could take different time. I think it is better tohave solution for this problem and deadlock should be detected.With Regards,Amit Kapila.EnterpriseDB: http://www.enterprisedb.com","msg_date":"Wed, 2 Sep 2015 17:12:42 +0530","msg_from":"Amit Kapila <amit.kapila16@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 2015/09/02 20:42, Amit Kapila wrote:\n> On Wed, Sep 2, 2015 at 4:19 PM, Pavan Deolasee <pavan.deolasee@gmail.com\n> <mailto:pavan.deolasee@gmail.com>> wrote:\n> > On Wed, Sep 2, 2015 at 3:55 PM, Amit Langote\n> <Langote_Amit_f8@lab.ntt.co.jp <mailto:Langote_Amit_f8@lab.ntt.co.jp>>\n> wrote:\n> >> On 2015-09-02 PM 06:41, Amit Langote wrote:\n> >> Which, I now realize, is not the worry Amit Kapila's expresses.\n\n> >> The deadlock was *indeed detected* in this case, with all the locks\n> in the\n> >> same PG instance. In a sharded environment with multiple PG instances,\n> >> that becomes tricky. DLM (distributed lock manager/deadlock detector)\n> >> seems indeed necessary as Amit K. suspects.\n\nAh, you are right.\n\n> > Right. XC/XL did not address this issue and they rely on statement\n> timeouts to break distributed deadlocks.\n\n> I think that will be difficult for application to decide and then it\n> needs to decide the same for all statements which is tricky because\n> different statements could take different time. I think it is better to\n> have solution for this problem and deadlock should be detected.\n\n+1\n\nBest regards,\nEtsuro Fujita\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 02 Sep 2015 21:55:04 +0900","msg_from":"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 06:11:45PM -0400, Bruce Momjian wrote:\n> Let me clearer about what the Citus Data paper shows. I said originally\n> that the data was sent to the coordinator, sorted, then resent to the\n> shards, but the document:\n> \n> \thttps://goo.gl/vJWF85\n> \thttps://www.citusdata.com/blog/114-how-to-build-your-distributed-database\n> \n> has the shards create the groups and the groups are sent to the other\n> shards. For example, to do COUNT(DISTINCT) if you have three shards,\n> then each shard breaks its data into 3 buckets (1B in size), then the\n> first bucket from each of the three shards goes to the first shard, and\n> the second bucket goes to the second shared, etc.\n> \n> Basically, they are doing map-reduce, and the shards are creating\n> additional batches that get shipped to other shards. I can see FDWs not\n> working well in that case as you are really creating a new data layout\n> just for the query. This explains why the XC/XL people are saying they\n> would use FDWs if they existed at the time they started development,\n> while the Citus Data people are saying they couldn't use FDWs as they\n> currently exist. They probably both needed FDW improvements, but I\n> think the Citus Data features would need a lot more.\n\nTo expand on this, using FDWs, it means each shard would create a\ntemporary table on the other shards and send some if its data to those\nshards. Once a shard gets all its data from the other shards, it will\nprocess the data and send the result to the collector.\n\nThat certainly seems like something FDWs would not do well. Frankly, I\nam unclear how Citus Data was able to do this with only backend hooks.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 10:05:58 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 7:08 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n\n> On Tue, Sep 1, 2015 at 12:00 AM, Pavan Deolasee\n> <pavan.deolasee@gmail.com> wrote:\n> > My worry is that if we start implementing them again from scratch, it\n> will\n> > take a few years before we get them in a usable state. What XC/XL lacked\n> is\n> > probably a Robert Haas or a Tom Lane who could look at the work and\n> suggest\n> > major edits. If that had happened, the quality of the product could have\n> > been much better today. I don't mean to derate the developers who worked\n> on\n> > XC/XL, but there is no harm in accepting that if someone with a much\n> better\n> > understanding of the whole system was part of the team, that would have\n> > positively impacted the project. Is that an angle worth exploring? Does\n> it\n> > make sense to commit some more resources to say XC or XL and try to\n> improve\n> > the quality of the product even further? To be honest, XL is in far far\n> > better shape (haven't really tried XC in a while) and some more\n> QA/polishing\n> > can make it production ready much sooner.\n>\n> From my point of view, and EnterpriseDB's point of view, anything that\n> doesn't go into the core PostgreSQL distribution isn't really getting\n> us where we need to be. If there's code in XL that would be valuable\n> to merge into core PostgreSQL, then let's do it. If the code cannot\n> be used but there are lessons we can learn that will make what does go\n> into core PostgreSQL better, let's learn them. However, I don't think\n> it's serving anybody very well that we have the XC fork, and multiple\n> forks of the XC fork, floating around out there and people are working\n> on those instead of working on core PostgreSQL. The reality is that\n> we don't have enough brainpower to spread it across 2 or 3 or 4 or 5\n> different projects and have all of them be good. The reality is,\n> also, that horizontal scalability isn't an optional feature. There\n> was a point in time at which the PostgreSQL project's official policy\n> on replication was that it did not belong in core. That was a bad\n> policy; thankfully, it was reversed, and the result was Hot Standby\n> and Streaming Replication, incredibly important technologies without\n> which we would not be where we are today. Horizontal scalability is\n> just as essential.\n>\n\nAgree with you, Robert.\n\nOne lesson from XL we got is that we need testing framework for cluster, so\nany cluster project should at least pass functional and performance\ntesting. XL was very easy to break and I'm wondering how many corner cases\nstill exists. We tried several other approaches and while reading the\npapers was a fun, in practice we found many devil details, which made the\npaper be just a paper.\n\n\n\n>\n> --\n> Robert Haas\n> EnterpriseDB: http://www.enterprisedb.com\n> The Enterprise PostgreSQL Company\n>\n\nOn Tue, Sep 1, 2015 at 7:08 PM, Robert Haas <robertmhaas@gmail.com> wrote:On Tue, Sep 1, 2015 at 12:00 AM, Pavan Deolasee\n<pavan.deolasee@gmail.com> wrote:\n> My worry is that if we start implementing them again from scratch, it will\n> take a few years before we get them in a usable state. What XC/XL lacked is\n> probably a Robert Haas or a Tom Lane who could look at the work and suggest\n> major edits. If that had happened, the quality of the product could have\n> been much better today. I don't mean to derate the developers who worked on\n> XC/XL, but there is no harm in accepting that if someone with a much better\n> understanding of the whole system was part of the team, that would have\n> positively impacted the project. Is that an angle worth exploring? Does it\n> make sense to commit some more resources to say XC or XL and try to improve\n> the quality of the product even further? To be honest, XL is in far far\n> better shape (haven't really tried XC in a while) and some more QA/polishing\n> can make it production ready much sooner.\n\nFrom my point of view, and EnterpriseDB's point of view, anything that\ndoesn't go into the core PostgreSQL distribution isn't really getting\nus where we need to be. If there's code in XL that would be valuable\nto merge into core PostgreSQL, then let's do it. If the code cannot\nbe used but there are lessons we can learn that will make what does go\ninto core PostgreSQL better, let's learn them. However, I don't think\nit's serving anybody very well that we have the XC fork, and multiple\nforks of the XC fork, floating around out there and people are working\non those instead of working on core PostgreSQL. The reality is that\nwe don't have enough brainpower to spread it across 2 or 3 or 4 or 5\ndifferent projects and have all of them be good. The reality is,\nalso, that horizontal scalability isn't an optional feature. There\nwas a point in time at which the PostgreSQL project's official policy\non replication was that it did not belong in core. That was a bad\npolicy; thankfully, it was reversed, and the result was Hot Standby\nand Streaming Replication, incredibly important technologies without\nwhich we would not be where we are today. Horizontal scalability is\njust as essential.Agree with you, Robert. One lesson from XL we got is that we need testing framework for cluster, so any cluster project should at least pass functional and performance testing. XL was very easy to break and I'm wondering how many corner cases still exists. We tried several other approaches and while reading the papers was a fun, in practice we found many devil details, which made the paper be just a paper. \n\n--\nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company","msg_date":"Wed, 2 Sep 2015 18:34:23 +0300","msg_from":"Oleg Bartunov <obartunov@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 09/01/2015 04:14 PM, Petr Jelinek wrote:\n> On 2015-09-02 00:09, Josh Berkus wrote:\n>> On 09/01/2015 02:29 PM, Tomas Vondra wrote:\n>>> So while you may be right in single-DC deployments, with multi-DC\n>>> deployments the situation is quite different - not only that the network\n>>> bandwidth is not unlimited, but because latencies within DC may be a\n>>> fraction of latencies between the locations (to the extent that the\n>>> increase due to syncrep may be just noise). So the local replication may\n>>> be actually way faster.\n>>\n>> I'm not seeing how the above is better using syncrep than using shard\n>> copying?\n> \n> Shard copying usually assumes that the origin node does the copy - the\n> data has to go twice through the slow connection. With replication you\n> can replicate locally over fast connection.\n\nAh, I was thinking of the case of having a single set of copies in the\nremote DC, but of course that isn't going to be the case with a highly\nredundant setup.\n\nBasically this seems to be saying that, in an ideal setup, we'd have\nsome kind of synchronous per-shard replication. We don't have that at\npresent (sync rep is whole-node, and BDR is asynchronous). There's also\nthe question of how to deal with failures and taking bad nodes out of\ncirculation in such a setup, especially considering that the writes\ncould be coming from multiple other nodes.\n\n>> Not really, the mechanism is different and the behavior is different.\n>> One critical deficiency in using binary syncrep is that you can't do\n>> round-robin redundancy at all; every redundant node has to be an exact\n>> mirror of another node. In a good HA distributed system, you want\n>> multiple shards per node, and you want each shard to be replicated to a\n>> different node, so that in the event of node failure you're not dumping\n>> the full load on one other server.\n>>\n> \n> This assumes that we use binary replication, but we can reasonably use\n> logical replication which can quite easily do filtering of what's\n> replicated where.\n\nIs there a way to do logical synchronous replication? I didn't think\nthere was.\n\n>>> IMHO the design has to address the multi-DC setups somehow. I think that\n>>> many of the customers who are so concerned about scaling to many shards\n>>> are also concerned about availability in case of DC outages, no?\n>>\n>> Certainly. But users located in a single DC shouldn't pay the same\n>> overhead as users who are geographically spread.\n>>\n> \n> Agreed, so we should support both ways, but I don't think it's necessary\n> to support both ways in version 0.1. It's just important to not paint\n> ourselves into a corner with design decisions that would make one of the\n> ways impossible.\n\nExactly!\n\nLet me explain why I'm so vocal on this point. PostgresXC didn't deal\nwith the redundancy/node replacement at all until after version 1.0.\nThen, when they tried to address it, they discovered that the code was\nchock full of assumptions that \"1 node == 1 shard\", and breaking that\nassumption would require a total refactor of the code (which never\nhappened). I don't want to see a repeat of that mistake.\n\nEven if it's only on paper, any new sharding design needs to address\nthese questions:\n\n1. How do we ensure no/minimal data is lost if we lose a node?\n2. How do we replace a lost node (without taking the cluster down)?\n 2. a. how do we allow an out-of-sync node to \"catch up\"?\n3. How do we maintain metadata about good/bad nodes (and shard locations)?\n4. How do we add nodes to expand the cluster?\n\nThere doesn't need to be code for all of the above from version 0.1, but\nthere needs to be a plan to tackle those problems. Otherwise, we'll\njust end up with another dead-end, not-useful-in-production technology.\n\n-- \nJosh Berkus\nPostgreSQL Experts Inc.\nhttp://pgexperts.com\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 10:57:30 -0700","msg_from":"Josh Berkus <josh@agliodbs.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Tue, Sep 1, 2015 at 11:18 AM, Robert Haas <robertmhaas@gmail.com> wrote:\n> It would be a bad idea to cling blindly to the FDW infrastructure if\n> it's fundamentally inadequate to do what we want. On the other hand,\n> it would also be a bad idea to set about recreating it without a\n> really good reason, and - just to take one example - the fact that it\n> doesn't currently push down DML operations to the remote side is not a\n> really good reason to rewrite the whole thing. On the contrary, it's\n> a reason to put some energy into the already-written patch which\n> implements that optimization.\n\nThe problem with FDW for these purposes as I see it is that too much\nintelligence is relegated to the implementer of the API. There needs\nto be a mechanism so that the planner can rewrite the remote query and\nthen do some after the fact processing. This exactly what citus does;\nif you send out AVG(foo) it rewrites that to SUM(foo) and COUNT(foo)\nso that aggregation can be properly weighted to the result. To do\nthis (distributed OLAP-type processing) right, the planner needs to\n*know* that this table is in fact distributed and also know that it\ncan make SQL compatible adjustments to the query.\n\nThis strikes me as a bit of a conflict of interest with FDW which\nseems to want to hide the fact that it's foreign; the FDW\nimplementation makes it's own optimization decisions which might make\nsense for single table queries but breaks down in the face of joins.\n\nmerlin\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 12:59:55 -0500","msg_from":"Merlin Moncure <mmoncure@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Wed, Sep 2, 2015 at 1:59 PM, Merlin Moncure <mmoncure@gmail.com> wrote:\n> On Tue, Sep 1, 2015 at 11:18 AM, Robert Haas <robertmhaas@gmail.com> wrote:\n>> It would be a bad idea to cling blindly to the FDW infrastructure if\n>> it's fundamentally inadequate to do what we want. On the other hand,\n>> it would also be a bad idea to set about recreating it without a\n>> really good reason, and - just to take one example - the fact that it\n>> doesn't currently push down DML operations to the remote side is not a\n>> really good reason to rewrite the whole thing. On the contrary, it's\n>> a reason to put some energy into the already-written patch which\n>> implements that optimization.\n>\n> The problem with FDW for these purposes as I see it is that too much\n> intelligence is relegated to the implementer of the API. There needs\n> to be a mechanism so that the planner can rewrite the remote query and\n> then do some after the fact processing. This exactly what citus does;\n> if you send out AVG(foo) it rewrites that to SUM(foo) and COUNT(foo)\n> so that aggregation can be properly weighted to the result. To do\n> this (distributed OLAP-type processing) right, the planner needs to\n> *know* that this table is in fact distributed and also know that it\n> can make SQL compatible adjustments to the query.\n>\n> This strikes me as a bit of a conflict of interest with FDW which\n> seems to want to hide the fact that it's foreign; the FDW\n> implementation makes it's own optimization decisions which might make\n> sense for single table queries but breaks down in the face of joins.\n\nWell, I don't think that ALL of the logic should go into the FDW. In\nparticular, in this example, parallel aggregate needs the same query\nrewrite, so the logic for that should live in core so that both\nparallel and distributed queries get the benefit.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 14:27:03 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Wed, Sep 2, 2015 at 1:57 PM, Josh Berkus <josh@agliodbs.com> wrote:\n> Even if it's only on paper, any new sharding design needs to address\n> these questions:\n>\n> 1. How do we ensure no/minimal data is lost if we lose a node?\n> 2. How do we replace a lost node (without taking the cluster down)?\n> 2. a. how do we allow an out-of-sync node to \"catch up\"?\n> 3. How do we maintain metadata about good/bad nodes (and shard locations)?\n> 4. How do we add nodes to expand the cluster?\n>\n> There doesn't need to be code for all of the above from version 0.1, but\n> there needs to be a plan to tackle those problems. Otherwise, we'll\n> just end up with another dead-end, not-useful-in-production technology.\n\nThis is a good point, and I think I agree with it. Let me make a few\nobservations:\n\n1. None of this stuff matters very much when the data is strictly\nread-only. You don't lose any data because you made enough copies at\nsome point in the distant past to ensure that you wouldn't. You\nreplace a lost node by taking anew copy. Nodes never need to catch up\nbecause there are no changes happening. To make bring up a new node,\nyou make a copy of an existing node (which doesn't change in the\nmeantime). So most of these concerns are about how to handle writes.\n\n2. None of this stuff matters when you only have one copy of the data.\nYour system is low-availability, but you just don't care for whatever\nreason. The issue arises when you have multiple copies of the data,\nand the data is being changed. Now, you have to worry about the\ncopies getting out of sync with each other, especially when failures\nhappen.\n\n3. IIUC, Postgres-XC handles this problem by reducing at least\nvolatile functions, maybe all functions, to constants. Then it\ngenerates an SQL statement to be sent to the data node to make the\nappropriate change. If there's more than one copy of the data, we\nsend a separate copy of the SQL statement to every node. I'm not sure\nexactly what happens if some of those nodes are not available, but I\ndon't think it's anything good. Fundamentally, this model doesn't\nallow for many good options in that case.\n\n4. Therefore, I think that we should instead use logical replication,\nwhich might be either synchronous or asynchronous. When you modify\none copy of the data, that change will then be replicated to all other\nnodes. If you are OK with eventual consistency, this replication can\nbe asynchronous, and nodes that are off-line will catch up when they\nare on-line. If you are not OK with that, then you must replicate\nsynchronously to every node before transaction commit; or at least you\nmust replicate synchronously to every node that is currently on-line.\nThis presents some challenges: logical decoding currently can't\nreplicate transactions that are still in process - replication starts\nwhen the transaction commits. Also, we don't have any way for\nsynchronous replication to wait for multiple nodes. But in theory\nthose seem like limitations that can be lifted. Also, the GTM needs\nto be aware that this stuff is happening, or it will DTWT. That too\nseems like a problem that can be solved.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 14:41:46 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 09/02/2015 11:41 AM, Robert Haas wrote:\n> On Wed, Sep 2, 2015 at 1:57 PM, Josh Berkus <josh@agliodbs.com> wrote:\n>> Even if it's only on paper, any new sharding design needs to address\n>> these questions:\n>>\n>> 1. How do we ensure no/minimal data is lost if we lose a node?\n>> 2. How do we replace a lost node (without taking the cluster down)?\n>> 2. a. how do we allow an out-of-sync node to \"catch up\"?\n>> 3. How do we maintain metadata about good/bad nodes (and shard locations)?\n>> 4. How do we add nodes to expand the cluster?\n>>\n>> There doesn't need to be code for all of the above from version 0.1, but\n>> there needs to be a plan to tackle those problems. Otherwise, we'll\n>> just end up with another dead-end, not-useful-in-production technology.\n> \n> This is a good point, and I think I agree with it. Let me make a few\n> observations:\n> \n> 1. None of this stuff matters very much when the data is strictly\n> read-only. \n\nYep.\n\n> 2. None of this stuff matters when you only have one copy of the data.\n> Your system is low-availability, but you just don't care for whatever\n> reason. \n\nUh-huh.\n\n> 3. IIUC, Postgres-XC handles this problem by reducing at least\n> volatile functions, maybe all functions, to constants. Then it\n> generates an SQL statement to be sent to the data node to make the\n> appropriate change. If there's more than one copy of the data, we\n> send a separate copy of the SQL statement to every node. I'm not sure\n> exactly what happens if some of those nodes are not available, but I\n> don't think it's anything good. Fundamentally, this model doesn't\n> allow for many good options in that case.\n\npg_shard also sends the data to each node, and automatically notices\nwhich nodes are not responding and takes them out of availability.\nThere isn't a \"catch up\" feature yet (AFAIK), or any attempt to reduce\nvolatile functions.\n\nFor that matter, last I worked on it Greenplum also did multiplexing via\nthe writing node (or via the data loader). So this is a popular\napproach; it has a number of drawbacks, though, of which volatile\nfunctions are a major one.\n\n> 4. Therefore, I think that we should instead use logical replication,\n> which might be either synchronous or asynchronous. When you modify\n> one copy of the data, that change will then be replicated to all other\n> nodes. If you are OK with eventual consistency, this replication can\n> be asynchronous, and nodes that are off-line will catch up when they\n> are on-line. If you are not OK with that, then you must replicate\n> synchronously to every node before transaction commit; or at least you\n> must replicate synchronously to every node that is currently on-line.\n> This presents some challenges: logical decoding currently can't\n> replicate transactions that are still in process - replication starts\n> when the transaction commits. Also, we don't have any way for\n> synchronous replication to wait for multiple nodes. \n\nWell, there is a WIP patch for that, which IMHO would be much improved\nby having a concrete use-case like this one. What nobody is working on\n-- and we've vetoed in the past -- is a way of automatically failing and\nremoving from replication any node which repeatedly fails to sync, which\nwould be a requirement for this model.\n\nYou'd also need a way to let the connection nodes know when a replica\nhas fallen behind so that they can be taken out of\nload-balancing/sharding for read queries. For the synchronous model,\nthat would be \"fallen behind at all\"; for asynchronous it would be\n\"fallen more than ### behind\".\n\n> But in theory\n> those seem like limitations that can be lifted. Also, the GTM needs\n> to be aware that this stuff is happening, or it will DTWT. That too\n> seems like a problem that can be solved.\n\nYeah? I'd assume that a GTM would be antithetical to two-stage copying.\n I'm not a big fan of a GTM at all, frankly; it makes clusters much\nharder to set up, and becomes a SPOF.\n\n-- \nJosh Berkus\nPostgreSQL Experts Inc.\nhttp://pgexperts.com\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 12:03:36 -0700","msg_from":"Josh Berkus <josh@agliodbs.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Wed, Sep 2, 2015 at 3:03 PM, Josh Berkus <josh@agliodbs.com> wrote:\n>> 4. Therefore, I think that we should instead use logical replication,\n>> which might be either synchronous or asynchronous. When you modify\n>> one copy of the data, that change will then be replicated to all other\n>> nodes. If you are OK with eventual consistency, this replication can\n>> be asynchronous, and nodes that are off-line will catch up when they\n>> are on-line. If you are not OK with that, then you must replicate\n>> synchronously to every node before transaction commit; or at least you\n>> must replicate synchronously to every node that is currently on-line.\n>> This presents some challenges: logical decoding currently can't\n>> replicate transactions that are still in process - replication starts\n>> when the transaction commits. Also, we don't have any way for\n>> synchronous replication to wait for multiple nodes.\n>\n> Well, there is a WIP patch for that, which IMHO would be much improved\n> by having a concrete use-case like this one. What nobody is working on\n> -- and we've vetoed in the past -- is a way of automatically failing and\n> removing from replication any node which repeatedly fails to sync, which\n> would be a requirement for this model.\n\nYep. It's clear to me we need that in general, not just for sharding.\nTo me, the key is to make sure there's a way for the cluster-ware to\nknow about the state transitions. Currently, when the synchronous\nstandby changes, PostgreSQL doesn't tell anyone. That's a problem.\n\n> You'd also need a way to let the connection nodes know when a replica\n> has fallen behind so that they can be taken out of\n> load-balancing/sharding for read queries. For the synchronous model,\n> that would be \"fallen behind at all\"; for asynchronous it would be\n> \"fallen more than ### behind\".\n\nHow is that different from the previous thing? Just that we'd treat\n\"lagging\" as \"down\" beyond some threshold? That doesn't seem like a\nmandatory feature.\n\n>> But in theory\n>> those seem like limitations that can be lifted. Also, the GTM needs\n>> to be aware that this stuff is happening, or it will DTWT. That too\n>> seems like a problem that can be solved.\n>\n> Yeah? I'd assume that a GTM would be antithetical to two-stage copying.\n\nI don't think so. If transaction A writes data on X which is\nreplicated to Y and then commits, a new snapshot which shows A as\ncommitted can't be used on Y until A's changes have been replicated\nthere. That could be enforced by having the commit of A wait for\nreplication, or by having an attempt by a later transaction to use the\nsnapshot on Y wait until replication completes, or some even more\nsophisticated strategy that considers whether the replication backlog\ntouches the same data that the new transaction will read. It's\ncomplicated, but it doesn't seem intractable.\n\n> I'm not a big fan of a GTM at all, frankly; it makes clusters much\n> harder to set up, and becomes a SPOF.\n\nI partially agree. I think it's very important that the GTM is an\noptional feature of whatever we end up with, rather than an\nindispensable component. People who don't want it shouldn't have to\npay the price in performance and administrative complexity. But at\nthe same time, I think a lot of people will want it, because without\nit, the fact that sharding is in use is much less transparent to the\napplication.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 15:30:14 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"\n\nOn 09/02/2015 08:27 PM, Robert Haas wrote:\n> On Wed, Sep 2, 2015 at 1:59 PM, Merlin Moncure <mmoncure@gmail.com>\n> wrote:\n>>\n>> This strikes me as a bit of a conflict of interest with FDW which\n>> seems to want to hide the fact that it's foreign; the FDW\n>> implementation makes it's own optimization decisions which might\n>> make sense for single table queries but breaks down in the face of\n>> joins.\n\n+1 to these concerns\n\n> Well, I don't think that ALL of the logic should go into the FDW.\n\nThen maybe we shouldn't call this \"FDW-based sharding\" (or \"FDW \napproach\" or whatever was used in this thread so far) because that kinda \nimplies that the proposal is to build on FDW.\n\nIn my mind, FDW is a wonderful tool to integrate PostgreSQL with \nexternal data sources, and it's nicely shaped for this purpose, which \nimplies the abstractions and assumptions in the code.\n\nThe truth however is that many current uses of the FDW API are actually \nusing it for different purposes because there's no other way to do that, \nnot because FDWs are the \"right way\". And this includes the attempts to \nbuild sharding on FDW, I think.\n\nSituations like this result in \"improvements\" of the API that seem to \nimprove the API for the second group, but make the life harder for the \noriginal FDW API audience by making the API needlessly complex. And I \nsay \"seem to improve\" because the second group eventually runs into the \nfundamental abstractions and assumptions the API is based on anyway.\n\nAnd based on the discussions at pgcon, I think this is the main reason \nwhy people cringe when they hear \"FDW\" and \"sharding\" in the same sentence.\n\nI'm not opposed to reusing the FDW infrastructure, of course.\n\n > In particular, in this example, parallel aggregate needs the same\n > query rewrite, so the logic for that should live in core so that\n > both parallel and distributed queries get the benefit.\n\nI'm not sure the parallel query is a great example here - maybe I'm \nwrong but I think it's a fairly isolated piece of code, and we have \npretty clear idea of the two use cases.\n\nI'm sure it's non-trivial to design it well for both cases, but I think \nthe questions for FWD/sharding will be much more about abstract concepts \nthan particular technical solutions.\n\nregards\n\n--\nTomas Vondra http://www.2ndQuadrant.com\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 02 Sep 2015 22:11:07 +0200","msg_from":"Tomas Vondra <tomas.vondra@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 09/02/2015 12:30 PM, Robert Haas wrote:\n> On Wed, Sep 2, 2015 at 3:03 PM, Josh Berkus <josh@agliodbs.com> wrote:\n>>> 4. Therefore, I think that we should instead use logical replication,\n>>> which might be either synchronous or asynchronous. When you modify\n>>> one copy of the data, that change will then be replicated to all other\n>>> nodes. If you are OK with eventual consistency, this replication can\n>>> be asynchronous, and nodes that are off-line will catch up when they\n>>> are on-line. If you are not OK with that, then you must replicate\n>>> synchronously to every node before transaction commit; or at least you\n>>> must replicate synchronously to every node that is currently on-line.\n>>> This presents some challenges: logical decoding currently can't\n>>> replicate transactions that are still in process - replication starts\n>>> when the transaction commits. Also, we don't have any way for\n>>> synchronous replication to wait for multiple nodes.\n>>\n>> Well, there is a WIP patch for that, which IMHO would be much improved\n>> by having a concrete use-case like this one. What nobody is working on\n>> -- and we've vetoed in the past -- is a way of automatically failing and\n>> removing from replication any node which repeatedly fails to sync, which\n>> would be a requirement for this model.\n> \n> Yep. It's clear to me we need that in general, not just for sharding.\n> To me, the key is to make sure there's a way for the cluster-ware to\n> know about the state transitions. Currently, when the synchronous\n> standby changes, PostgreSQL doesn't tell anyone. That's a problem.\n\nThere are many parts of our replication which are still effectively\nunmonitorable. For example, there's still no way to tell from the\nreplica that it's lost contact with the master except by tailing the\nlog. If we try to build bigger systems on top of these components,\nwe'll find that we need to add a lot of instrumentation.\n\n> \n>> You'd also need a way to let the connection nodes know when a replica\n>> has fallen behind so that they can be taken out of\n>> load-balancing/sharding for read queries. For the synchronous model,\n>> that would be \"fallen behind at all\"; for asynchronous it would be\n>> \"fallen more than ### behind\".\n> \n> How is that different from the previous thing? Just that we'd treat\n> \"lagging\" as \"down\" beyond some threshold? That doesn't seem like a\n> mandatory feature.\n\nIt's a mandatory feature if you want to load-balance reads. We have to\nknow which nodes not to send reads to because they are out of sync.\n\n>> Yeah? I'd assume that a GTM would be antithetical to two-stage copying.\n> \n> I don't think so. If transaction A writes data on X which is\n> replicated to Y and then commits, a new snapshot which shows A as\n> committed can't be used on Y until A's changes have been replicated\n> there. That could be enforced by having the commit of A wait for\n> replication, or by having an attempt by a later transaction to use the\n> snapshot on Y wait until replication completes, or some even more\n> sophisticated strategy that considers whether the replication backlog\n> touches the same data that the new transaction will read. It's\n> complicated, but it doesn't seem intractable.\n\nI need to see this on a chalkboard to understand it.\n\n>> I'm not a big fan of a GTM at all, frankly; it makes clusters much\n>> harder to set up, and becomes a SPOF.\n> \n> I partially agree. I think it's very important that the GTM is an\n> optional feature of whatever we end up with, rather than an\n> indispensable component. People who don't want it shouldn't have to\n> pay the price in performance and administrative complexity. But at\n> the same time, I think a lot of people will want it, because without\n> it, the fact that sharding is in use is much less transparent to the\n> application.\n\nIf it can be optional, then we're pretty close to covering most use\ncases with one general infrastructure. That would be nice.\n\n-- \nJosh Berkus\nPostgreSQL Experts Inc.\nhttp://pgexperts.com\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 14:36:30 -0700","msg_from":"Josh Berkus <josh@agliodbs.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Wed, Sep 2, 2015 at 02:41:46PM -0400, Robert Haas wrote:\n> 4. Therefore, I think that we should instead use logical replication,\n> which might be either synchronous or asynchronous. When you modify\n> one copy of the data, that change will then be replicated to all other\n> nodes. If you are OK with eventual consistency, this replication can\n> be asynchronous, and nodes that are off-line will catch up when they\n> are on-line. If you are not OK with that, then you must replicate\n> synchronously to every node before transaction commit; or at least you\n> must replicate synchronously to every node that is currently on-line.\n> This presents some challenges: logical decoding currently can't\n> replicate transactions that are still in process - replication starts\n> when the transaction commits. Also, we don't have any way for\n> synchronous replication to wait for multiple nodes. But in theory\n> those seem like limitations that can be lifted. Also, the GTM needs\n> to be aware that this stuff is happening, or it will DTWT. That too\n> seems like a problem that can be solved.\n\nCan you explain why logical replication is better than binary\nreplication for this use-case?\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 18:56:29 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Wed, Sep 2, 2015 at 12:03:36PM -0700, Josh Berkus wrote:\n> Well, there is a WIP patch for that, which IMHO would be much improved\n> by having a concrete use-case like this one. What nobody is working on\n> -- and we've vetoed in the past -- is a way of automatically failing and\n> removing from replication any node which repeatedly fails to sync, which\n> would be a requirement for this model.\n> \n> You'd also need a way to let the connection nodes know when a replica\n> has fallen behind so that they can be taken out of\n> load-balancing/sharding for read queries. For the synchronous model,\n> that would be \"fallen behind at all\"; for asynchronous it would be\n> \"fallen more than ### behind\".\n\nI think this gets back to the idea of running an administrative alert\ncommand when we switch to using a different server for\nsynchronous_standby_names. We can't just keep requiring external\ntooling to identify things that the database knows easily and can send\nan alert. Removing failed nodes is also something we should do and\nnotify users about.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 19:14:43 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Wed, Sep 2, 2015 at 6:56 PM, Bruce Momjian <bruce@momjian.us> wrote:\n> On Wed, Sep 2, 2015 at 02:41:46PM -0400, Robert Haas wrote:\n>> 4. Therefore, I think that we should instead use logical replication,\n>> which might be either synchronous or asynchronous. When you modify\n>> one copy of the data, that change will then be replicated to all other\n>> nodes. If you are OK with eventual consistency, this replication can\n>> be asynchronous, and nodes that are off-line will catch up when they\n>> are on-line. If you are not OK with that, then you must replicate\n>> synchronously to every node before transaction commit; or at least you\n>> must replicate synchronously to every node that is currently on-line.\n>> This presents some challenges: logical decoding currently can't\n>> replicate transactions that are still in process - replication starts\n>> when the transaction commits. Also, we don't have any way for\n>> synchronous replication to wait for multiple nodes. But in theory\n>> those seem like limitations that can be lifted. Also, the GTM needs\n>> to be aware that this stuff is happening, or it will DTWT. That too\n>> seems like a problem that can be solved.\n>\n> Can you explain why logical replication is better than binary\n> replication for this use-case?\n\nUh, well, for the same reasons it is better in many other cases.\nParticularly, you probably don't want to replicate all the data on\nmachine A to machine B, just some of it.\n\nTypically, sharding solutions store multiple copies of each piece of\ndata. So let's say you have 4 machines. You divide the data into 12\nchunks. Each machine is the write-master for 2 of those chunks, but\nhas secondary copies of 3 others. So maybe things start out like\nthis:\n\nmachine #1: master for chunks 1, 2, 3; also has copies of chunks 4, 7, 10\nmachine #2: master for chunks 4, 5, 6; also has copies of chunks 1, 8, 11\nmachine #3: master for chunks 7, 8, 9; also has copies of chunks 2, 5, 12\nmachine #4: master for chunks 10, 11, 12; also has copies of chunks 3, 6, 9\n\nIf machine #1 is run over by a rabid triceratops, you can make machine\n#2 the master for chunk 1, machine #3 the master for chunk 2, and\nmachine #4 the master for chunk 3. The write load therefore remains\nevenly divided. If you can only copy entire machines, you can't\nachieve that in this situation.\n\nI'm not saying that the above is exactly what we're going to end up\nwith, or even necessarily close. But a big part of the point of\nsharding is that not all the machines have the same data - otherwise\nyou are not write scaling. But it will frequently be the case, for\nvarious reasons, that they have *overlapping* sets of data. Logical\nreplication can handle that; physical replication can't.\n\nIn Postgres-XC, all tables are either sharded (part of the table is\npresent on each node) or distributed (all of the table is present on\nevery node). Clearly, there's no way to use physical replication in\nthat scenario except if you are OK with having two copies of every\nnode. But that's not a very good solution.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 21:03:25 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Thu, Sep 3, 2015 at 3:41 AM, Robert Haas wrote:\n> 3. IIUC, Postgres-XC handles this problem by reducing at least\n> volatile functions, maybe all functions, to constants. Then it\n> generates an SQL statement to be sent to the data node to make the\n> appropriate change. If there's more than one copy of the data, we\n> send a separate copy of the SQL statement to every node. I'm not sure\n> exactly what happens if some of those nodes are not available, but I\n> don't think it's anything good. Fundamentally, this model doesn't\n> allow for many good options in that case.\n\nI don't recall that. Immutable functions are switched to constants in\nthe query sent to datanodes. Volatile and stable functions are\nevaluated locally after fetching the results from the remote node. Not\nthat efficient for warehouse loads. My 2c.\n\n> 4. Therefore, I think that we should instead use logical replication,\n> which might be either synchronous or asynchronous. When you modify\n> one copy of the data, that change will then be replicated to all other\n> nodes. If you are OK with eventual consistency, this replication can\n> be asynchronous, and nodes that are off-line will catch up when they\n> are on-line. If you are not OK with that, then you must replicate\n> synchronously to every node before transaction commit; or at least you\n> must replicate synchronously to every node that is currently on-line.\n> This presents some challenges: logical decoding currently can't\n> replicate transactions that are still in process - replication starts\n> when the transaction commits. Also, we don't have any way for\n> synchronous replication to wait for multiple nodes.\n\nThat's something that the quorum synchronous patch would address.\nStill, having the possibility to be synchronous across multiple nodes\ndoes not seem like to be something at the top of the list.\n\n> Also, the GTM needs to be aware that this stuff is happening, or it will DTWT. That too seems like a problem that can be solved.\n\nIf I understood correctly, yes it is with its centralized transaction\nfacility each node is aware of the transaction status via the global\nsnapshot.\n-- \nMichael\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 3 Sep 2015 11:26:11 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 09/02/2015 03:56 PM, Bruce Momjian wrote:\n> On Wed, Sep 2, 2015 at 02:41:46PM -0400, Robert Haas wrote:\n>> 4. Therefore, I think that we should instead use logical replication,\n>> which might be either synchronous or asynchronous. When you modify\n>> one copy of the data, that change will then be replicated to all other\n>> nodes. If you are OK with eventual consistency, this replication can\n>> be asynchronous, and nodes that are off-line will catch up when they\n>> are on-line. If you are not OK with that, then you must replicate\n>> synchronously to every node before transaction commit; or at least you\n>> must replicate synchronously to every node that is currently on-line.\n>> This presents some challenges: logical decoding currently can't\n>> replicate transactions that are still in process - replication starts\n>> when the transaction commits. Also, we don't have any way for\n>> synchronous replication to wait for multiple nodes. But in theory\n>> those seem like limitations that can be lifted. Also, the GTM needs\n>> to be aware that this stuff is happening, or it will DTWT. That too\n>> seems like a problem that can be solved.\n>\n> Can you explain why logical replication is better than binary\n> replication for this use-case?\n>\n\nSelectivity?\n\nJD\n\n\n-- \nCommand Prompt, Inc. - http://www.commandprompt.com/ 503-667-4564\nPostgreSQL Centered full stack support, consulting and development.\nAnnouncing \"I'm offended\" is basically telling the world you can't\ncontrol your own emotions, so everyone else should do it for you.\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 19:50:25 -0700","msg_from":"\"Joshua D. Drake\" <jd@commandprompt.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Wed, Sep 2, 2015 at 07:50:25PM -0700, Joshua Drake wrote:\n> >Can you explain why logical replication is better than binary\n> >replication for this use-case?\n> >\n> \n> Selectivity?\n\nI was assuming you would just create identical slaves to handle failure,\nrather than moving selected data around.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 22:58:26 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Wed, Sep 2, 2015 at 09:03:25PM -0400, Robert Haas wrote:\n> > Can you explain why logical replication is better than binary\n> > replication for this use-case?\n> \n> Uh, well, for the same reasons it is better in many other cases.\n> Particularly, you probably don't want to replicate all the data on\n> machine A to machine B, just some of it.\n> \n> Typically, sharding solutions store multiple copies of each piece of\n> data. So let's say you have 4 machines. You divide the data into 12\n> chunks. Each machine is the write-master for 2 of those chunks, but\n> has secondary copies of 3 others. So maybe things start out like\n> this:\n> \n> machine #1: master for chunks 1, 2, 3; also has copies of chunks 4, 7, 10\n> machine #2: master for chunks 4, 5, 6; also has copies of chunks 1, 8, 11\n> machine #3: master for chunks 7, 8, 9; also has copies of chunks 2, 5, 12\n> machine #4: master for chunks 10, 11, 12; also has copies of chunks 3, 6, 9\n> \n> If machine #1 is run over by a rabid triceratops, you can make machine\n> #2 the master for chunk 1, machine #3 the master for chunk 2, and\n> machine #4 the master for chunk 3. The write load therefore remains\n> evenly divided. If you can only copy entire machines, you can't\n> achieve that in this situation.\n\nI see the advantage of this now. My original idea is that each shard\nwould have its own standby for disaster recovery, but your approach\nabove, which I know is typical, allows the shards to back up each other.\nYou could say shard 2 is the backup for shard 1, but then if shard one\ngoes bad, the entire workload of shard 1 goes to shard 2. With the\nabove approach, the load of shard 1 is shared by all the shards.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Wed, 2 Sep 2015 23:01:31 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Thu, Sep 3, 2015 at 8:28 AM, Bruce Momjian <bruce@momjian.us> wrote:\n>\n> On Wed, Sep 2, 2015 at 07:50:25PM -0700, Joshua Drake wrote:\n> > >Can you explain why logical replication is better than binary\n> > >replication for this use-case?\n> > >\n> >\n> > Selectivity?\n>\n> I was assuming you would just create identical slaves to handle failure,\n> rather than moving selected data around.\n>\n\nYes, I also think so, otherwise when the shard goes down and it's replica\nhas to take the place of shard, it will take more time to make replica\navailable as it won't have all the data as original shard had.\n\n\nWith Regards,\nAmit Kapila.\nEnterpriseDB: http://www.enterprisedb.com\n\nOn Thu, Sep 3, 2015 at 8:28 AM, Bruce Momjian <bruce@momjian.us> wrote:>> On Wed, Sep 2, 2015 at 07:50:25PM -0700, Joshua Drake wrote:> > >Can you explain why logical replication is better than binary> > >replication for this use-case?> > >> >> > Selectivity?>> I was assuming you would just create identical slaves to handle failure,> rather than moving selected data around.>Yes, I also think so, otherwise when the shard goes down and it's replicahas to take the place of shard, it will take more time to make replicaavailable as it won't have all the data as original shard had. With Regards,Amit Kapila.EnterpriseDB: http://www.enterprisedb.com","msg_date":"Thu, 3 Sep 2015 08:32:34 +0530","msg_from":"Amit Kapila <amit.kapila16@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Wed, Sep 2, 2015 at 9:04 PM, Oleg Bartunov <obartunov@gmail.com> wrote:\n\n>\n>\n>\n> One lesson from XL we got is that we need testing framework for cluster,\n> so any cluster project should at least pass functional and performance\n> testing.\n>\n\n+1. In early XC days, we focused a lot on adding newer features and\nsupporting as many PG features as possible. That took its toll on the\ntesting and QA. It was a mistake though my feeling was we tried to correct\nthat to some extend with XL. We did a 9.5 merge, which of course was a big\ndeal, but other than more time is being spent on improving stability and\nperformance\n\nXL was very easy to break and I'm wondering how many corner cases still\n> exists.\n>\n\nYour team reported 2 or 3 major issues which I think we were able to fix\nquite quickly. But if there are more such issues which your team has\nrecorded somewhere, I would request you to send them to the XL mailing\nlist. I would definitely want to look at them and address them.\n\nThanks,\nPavan\n\n-- \n Pavan Deolasee http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\nOn Wed, Sep 2, 2015 at 9:04 PM, Oleg Bartunov <obartunov@gmail.com> wrote:One lesson from XL we got is that we need testing framework for cluster, so any cluster project should at least pass functional and performance testing.+1. In early XC days, we focused a lot on adding newer features and supporting as many PG features as possible. That took its toll on the testing and QA. It was a mistake though my feeling was we tried to correct that to some extend with XL. We did a 9.5 merge, which of course was a big deal, but other than more time is being spent on improving stability and performance XL was very easy to break and I'm wondering how many corner cases still exists. Your team reported 2 or 3 major issues which I think we were able to fix quite quickly. But if there are more such issues which your team has recorded somewhere, I would request you to send them to the XL mailing list. I would definitely want to look at them and address them.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services","msg_date":"Thu, 3 Sep 2015 11:01:57 +0530","msg_from":"Pavan Deolasee <pavan.deolasee@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":">> One lesson from XL we got is that we need testing framework for cluster,\n>> so any cluster project should at least pass functional and performance\n>> testing.\n>>\n> \n> +1. In early XC days, we focused a lot on adding newer features and\n> supporting as many PG features as possible. That took its toll on the\n> testing and QA. It was a mistake though my feeling was we tried to correct\n> that to some extend with XL. We did a 9.5 merge, which of course was a big\n> deal, but other than more time is being spent on improving stability and\n> performance\n\nAgreed. Any cluster project needs a cluster testing framework.\n\npgpool-II project runs \"build farm\" which runs cluster regression\ntests every day. The tests includes several versions of pgpool-II and\nPostgreSQL combinations using docker. Still it needs more tests but\neven with limited test cases, it is pretty usefull to detect bugs.\n\nBest regards,\n--\nTatsuo Ishii\nSRA OSS, Inc. Japan\nEnglish: http://www.sraoss.co.jp/index_en.php\nJapanese:http://www.sraoss.co.jp\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 03 Sep 2015 14:42:02 +0900 (JST)","msg_from":"Tatsuo Ishii <ishii@postgresql.org>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"Hi,\n\nOn 09/03/2015 05:02 AM, Amit Kapila wrote:\n> On Thu, Sep 3, 2015 at 8:28 AM, Bruce Momjian <bruce@momjian.us\n> <mailto:bruce@momjian.us>> wrote:\n> >\n> > On Wed, Sep 2, 2015 at 07:50:25PM -0700, Joshua Drake wrote:\n> > > >Can you explain why logical replication is better than binary\n> > > >replication for this use-case?\n> > > >\n> > >\n> > > Selectivity?\n> >\n>> I was assuming you would just create identical slaves to handle\n>> failure, rather than moving selected data around.\n> >\n>\n> Yes, I also think so, otherwise when the shard goes down and it's\n> replica has to take the place of shard, it will take more time to\n> make replica available as it won't have all the data as original\n> shard had.\n\nNot really, the idea is that you don't need to create the replica \nimmediately. The system recognizes that primary shard location is \nunavailable and redirects the tasks to the \"replicas.\" So the time to \nrecreate the failed node is not that critical.\n\nIt needs to be done in a smart way to prevent some typical issues like \nsuddenly doubling the load on replicas due to failure of the primary \nlocation. By using different group of nodes for each \"data segment\" you \ncan eliminate this, because the group of nodes to handle the additional \nload will be larger.\n\nThe other issue then of course is that the groups of nodes must not be \nentirely random, otherwise the cluster would suffer data loss in case of \noutage of arbitrary group of K nodes (where K is the number of replicas \nfor each piece of data).\n\nIt's also non-trivial to do this when you have to consider racks, data \ncenters etc.\n\nWith regular slaves you can't do any of this - no matter what you do, \nyou have to load balance the additional load only on the slaves.\n\nregards\n\n--\nTomas Vondra http://www.2ndQuadrant.com\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 03 Sep 2015 15:40:40 +0200","msg_from":"Tomas Vondra <tomas.vondra@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"Josh Berkus <josh@agliodbs.com> wrote:\n\n>>> You'd also need a way to let the connection nodes know when a replica\n>>> has fallen behind so that they can be taken out of\n>>> load-balancing/sharding for read queries. For the synchronous model,\n>>> that would be \"fallen behind at all\"; for asynchronous it would be\n>>> \"fallen more than ### behind\".\n>>\n>> How is that different from the previous thing? Just that we'd treat\n>> \"lagging\" as \"down\" beyond some threshold? That doesn't seem like a\n>> mandatory feature.\n>\n> It's a mandatory feature if you want to load-balance reads. We have to\n> know which nodes not to send reads to because they are out of sync.\n\nThere is another approach to this that we should consider how (if?)\nwe are going to cover: database affinity. I have seen cases where\nthere are multiple databases which are targets of asynchronous\nreplication, with a web application load balancing among them. The\napplication kept track of which copy each connection was using, so\nthat if when they were not exactly in sync the user never saw \"time\nmoving backward\". Two different users might see versions of the\ndata from different points in time, but that generally doesn't\nmatter, especially if the difference is just a few minutes. If one\ncopy got too far behind for some reason, they would load-shift to\nthe other servers (time still moves forward, only there is a \"jump\"\nforward at the shift). This would allow the tardy database to be\ndedicated to catching up again.\n\nBottom line is that this very smooth behavior required two features\n-- the ability for the application to control database affinity,\nand the ability to shift that affinity gracefully (with no down\ntime).\n\n--\nKevin Grittner\nEDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 3 Sep 2015 14:00:17 +0000 (UTC)","msg_from":"Kevin Grittner <kgrittn@ymail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Thu, Sep 3, 2015 at 03:40:40PM +0200, Tomas Vondra wrote:\n> Not really, the idea is that you don't need to create the replica\n> immediately. The system recognizes that primary shard location is\n> unavailable and redirects the tasks to the \"replicas.\" So the time\n> to recreate the failed node is not that critical.\n> \n> It needs to be done in a smart way to prevent some typical issues\n> like suddenly doubling the load on replicas due to failure of the\n> primary location. By using different group of nodes for each \"data\n> segment\" you can eliminate this, because the group of nodes to\n> handle the additional load will be larger.\n> \n> The other issue then of course is that the groups of nodes must not\n> be entirely random, otherwise the cluster would suffer data loss in\n> case of outage of arbitrary group of K nodes (where K is the number\n> of replicas for each piece of data).\n> \n> It's also non-trivial to do this when you have to consider racks,\n> data centers etc.\n> \n> With regular slaves you can't do any of this - no matter what you\n> do, you have to load balance the additional load only on the slaves.\n\nYes, and imagine doing this with FDW's, updating the catalog table\nlocation of the FDW as part of the failover process --- interesting.\n\n-- \n Bruce Momjian <bruce@momjian.us> http://momjian.us\n EnterpriseDB http://enterprisedb.com\n\n + Everyone has their own god. +\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Thu, 3 Sep 2015 10:02:10 -0400","msg_from":"Bruce Momjian <bruce@momjian.us>","msg_from_op":true,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"Hey Robert,\n\nNow the question is, where should the code that does all of this live?\n> postgres_fdw? Some new, sharding-specific FDW? In core? I don't\n> know for sure, but what I do know is that we could make a lot of\n> progress over where we are today by just improving postgres_fdw, and I\n> don't think those improvements are even all that difficult. If we\n> decide we need to implement something new, it's going to be a huge\n> project that will take years to complete, with uncertain results. I'd\n> rather have a postgres_fdw-based implementation that is imperfect and\n> can't handle some kinds of queries in 9.6 than a promise that by 9.9\n> we'll have something really great that handles MPP perfectly.\n>\n\nDistributed shuffles (Map/Reduce) are hard. When we looked at using FDWs\nfor pg_shard, we thought that Map/Reduce would require a comprehensive\nrevamp of the APIs.\n\nFor Citus, a second part of the question is as FDW writers. We implemented\ncstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't benefit from\neven the simple join pushdown that doesn't require Map/Reduce.\n\nThe PostgreSQL wiki lists 85 foreign data wrappers, and only 18 of these\nhave support for joins:\nhttps://wiki.postgresql.org/wiki/Foreign_data_wrappers\n\nBest,\nOzgun\n\nHey Robert,Now the question is, where should the code that does all of this live?\n postgres_fdw? Some new, sharding-specific FDW? In core? I don't\nknow for sure, but what I do know is that we could make a lot of\nprogress over where we are today by just improving postgres_fdw, and I\ndon't think those improvements are even all that difficult. If we\ndecide we need to implement something new, it's going to be a huge\nproject that will take years to complete, with uncertain results. I'd\nrather have a postgres_fdw-based implementation that is imperfect and\ncan't handle some kinds of queries in 9.6 than a promise that by 9.9\nwe'll have something really great that handles MPP perfectly.Distributed shuffles (Map/Reduce) are hard. When we looked at using FDWs for pg_shard, we thought that Map/Reduce would require a comprehensive revamp of the APIs.For Citus, a second part of the question is as FDW writers. We implemented cstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't benefit from even the simple join pushdown that doesn't require Map/Reduce.The PostgreSQL wiki lists 85 foreign data wrappers, and only 18 of these have support for joins: https://wiki.postgresql.org/wiki/Foreign_data_wrappersBest,Ozgun","msg_date":"Fri, 4 Sep 2015 15:52:49 -0700","msg_from":"Ozgun Erdogan <ozgun@citusdata.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Sat, Sep 5, 2015 at 4:22 AM, Ozgun Erdogan <ozgun@citusdata.com> wrote:\n\n> Hey Robert,\n>\n> Now the question is, where should the code that does all of this live?\n>> postgres_fdw? Some new, sharding-specific FDW? In core? I don't\n>> know for sure, but what I do know is that we could make a lot of\n>> progress over where we are today by just improving postgres_fdw, and I\n>> don't think those improvements are even all that difficult. If we\n>> decide we need to implement something new, it's going to be a huge\n>> project that will take years to complete, with uncertain results. I'd\n>> rather have a postgres_fdw-based implementation that is imperfect and\n>> can't handle some kinds of queries in 9.6 than a promise that by 9.9\n>> we'll have something really great that handles MPP perfectly.\n>>\n>\n> Distributed shuffles (Map/Reduce) are hard. When we looked at using FDWs\n> for pg_shard, we thought that Map/Reduce would require a comprehensive\n> revamp of the APIs.\n>\n> For Citus, a second part of the question is as FDW writers. We implemented\n> cstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't benefit from\n> even the simple join pushdown that doesn't require Map/Reduce.\n>\n\nI didn't get this. Join pushdown infrastructure (chiefly set of hooks\nprovided in join planning paths) is part of 9.5. Isn't that sufficient to\nimplement join push-down for above FDWs? Or FDW writers are facing problems\nwhile implementing those hooks. In either case that should be reported on\nhackers.\n\n\n>\n> The PostgreSQL wiki lists 85 foreign data wrappers, and only 18 of these\n> have support for joins:\n> https://wiki.postgresql.org/wiki/Foreign_data_wrappers\n>\n> Best,\n> Ozgun\n>\n\n\n\n-- \nBest Wishes,\nAshutosh Bapat\nEnterpriseDB Corporation\nThe Postgres Database Company\n\nOn Sat, Sep 5, 2015 at 4:22 AM, Ozgun Erdogan <ozgun@citusdata.com> wrote:Hey Robert,Now the question is, where should the code that does all of this live?\n postgres_fdw? Some new, sharding-specific FDW? In core? I don't\nknow for sure, but what I do know is that we could make a lot of\nprogress over where we are today by just improving postgres_fdw, and I\ndon't think those improvements are even all that difficult. If we\ndecide we need to implement something new, it's going to be a huge\nproject that will take years to complete, with uncertain results. I'd\nrather have a postgres_fdw-based implementation that is imperfect and\ncan't handle some kinds of queries in 9.6 than a promise that by 9.9\nwe'll have something really great that handles MPP perfectly.Distributed shuffles (Map/Reduce) are hard. When we looked at using FDWs for pg_shard, we thought that Map/Reduce would require a comprehensive revamp of the APIs.For Citus, a second part of the question is as FDW writers. We implemented cstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't benefit from even the simple join pushdown that doesn't require Map/Reduce.I didn't get this. Join pushdown infrastructure (chiefly set of hooks provided in join planning paths) is part of 9.5. Isn't that sufficient to implement join push-down for above FDWs? Or FDW writers are facing problems while implementing those hooks. In either case that should be reported on hackers. The PostgreSQL wiki lists 85 foreign data wrappers, and only 18 of these have support for joins: https://wiki.postgresql.org/wiki/Foreign_data_wrappersBest,Ozgun\n-- Best Wishes,Ashutosh BapatEnterpriseDB CorporationThe Postgres Database Company","msg_date":"Mon, 7 Sep 2015 11:13:39 +0530","msg_from":"Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"I\n\nOn Monday, September 7, 2015, Ashutosh Bapat <\nashutosh.bapat@enterprisedb.com> wrote:\n\n>\n>\n> On Sat, Sep 5, 2015 at 4:22 AM, Ozgun Erdogan <ozgun@citusdata.com\n> <javascript:_e(%7B%7D,'cvml','ozgun@citusdata.com');>> wrote:\n>\n>> Hey Robert,\n>>\n>> Now the question is, where should the code that does all of this live?\n>>> postgres_fdw? Some new, sharding-specific FDW? In core? I don't\n>>> know for sure, but what I do know is that we could make a lot of\n>>> progress over where we are today by just improving postgres_fdw, and I\n>>> don't think those improvements are even all that difficult. If we\n>>> decide we need to implement something new, it's going to be a huge\n>>> project that will take years to complete, with uncertain results. I'd\n>>> rather have a postgres_fdw-based implementation that is imperfect and\n>>> can't handle some kinds of queries in 9.6 than a promise that by 9.9\n>>> we'll have something really great that handles MPP perfectly.\n>>>\n>>\n>> Distributed shuffles (Map/Reduce) are hard. When we looked at using FDWs\n>> for pg_shard, we thought that Map/Reduce would require a comprehensive\n>> revamp of the APIs.\n>>\n>> For Citus, a second part of the question is as FDW writers. We\n>> implemented cstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't\n>> benefit from even the simple join pushdown that doesn't require Map/Reduce.\n>>\n>\n> I didn't get this. Join pushdown infrastructure (chiefly set of hooks\n> provided in join planning paths) is part of 9.5. Isn't that sufficient to\n> implement join push-down for above FDWs? Or FDW writers are facing problems\n> while implementing those hooks. In either case that should be reported on\n> hackers.\n>\n>\n\nI don't think any FDW writer (other the postgres_fdw) has tried to\nimplement join push down in the respective FDW's using the new API.\n\n\n>\n>> The PostgreSQL wiki lists 85 foreign data wrappers, and only 18 of these\n>> have support for joins:\n>> https://wiki.postgresql.org/wiki/Foreign_data_wrappers\n>>\n>> Best,\n>> Ozgun\n>>\n>\n>\n>\n> --\n> Best Wishes,\n> Ashutosh Bapat\n> EnterpriseDB Corporation\n> The Postgres Database Company\n>\n\n\n-- \nAhsan Hadi\nSnr Director Product Development\nEnterpriseDB Corporation\nThe Enterprise Postgres Company\n\nPhone: +92-51-8358874\nMobile: +92-333-5162114\n\nWebsite: www.enterprisedb.com\nEnterpriseDB Blog: http://blogs.enterprisedb.com/\nFollow us on Twitter: http://www.twitter.com/enterprisedb\n\nThis e-mail message (and any attachment) is intended for the use of the\nindividual or entity to whom it is addressed. This message contains\ninformation from EnterpriseDB Corporation that may be privileged,\nconfidential, or exempt from disclosure under applicable law. If you are\nnot the intended recipient or authorized to receive this for the intended\nrecipient, any use, dissemination, distribution, retention, archiving, or\ncopying of this communication is strictly prohibited. If you have received\nthis e-mail in error, please notify the sender immediately by reply e-mail\nand delete this message.\n\nI On Monday, September 7, 2015, Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:On Sat, Sep 5, 2015 at 4:22 AM, Ozgun Erdogan <ozgun@citusdata.com> wrote:Hey Robert,Now the question is, where should the code that does all of this live?\n postgres_fdw? Some new, sharding-specific FDW? In core? I don't\nknow for sure, but what I do know is that we could make a lot of\nprogress over where we are today by just improving postgres_fdw, and I\ndon't think those improvements are even all that difficult. If we\ndecide we need to implement something new, it's going to be a huge\nproject that will take years to complete, with uncertain results. I'd\nrather have a postgres_fdw-based implementation that is imperfect and\ncan't handle some kinds of queries in 9.6 than a promise that by 9.9\nwe'll have something really great that handles MPP perfectly.Distributed shuffles (Map/Reduce) are hard. When we looked at using FDWs for pg_shard, we thought that Map/Reduce would require a comprehensive revamp of the APIs.For Citus, a second part of the question is as FDW writers. We implemented cstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't benefit from even the simple join pushdown that doesn't require Map/Reduce.I didn't get this. Join pushdown infrastructure (chiefly set of hooks provided in join planning paths) is part of 9.5. Isn't that sufficient to implement join push-down for above FDWs? Or FDW writers are facing problems while implementing those hooks. In either case that should be reported on hackers. I don't think any FDW writer (other the postgres_fdw) has tried to implement join push down in the respective FDW's using the new API. The PostgreSQL wiki lists 85 foreign data wrappers, and only 18 of these have support for joins: https://wiki.postgresql.org/wiki/Foreign_data_wrappersBest,Ozgun\n-- Best Wishes,Ashutosh BapatEnterpriseDB CorporationThe Postgres Database Company\n\n-- Ahsan HadiSnr Director Product DevelopmentEnterpriseDB CorporationThe Enterprise Postgres CompanyPhone: +92-51-8358874 Mobile: +92-333-5162114Website: www.enterprisedb.comEnterpriseDB Blog: http://blogs.enterprisedb.com/Follow us on Twitter: http://www.twitter.com/enterprisedbThis e-mail message (and any attachment) is intended for the use of the individual or entity to whom it is addressed. This message contains information from EnterpriseDB Corporation that may be privileged, confidential, or exempt from disclosure under applicable law. If you are not the intended recipient or authorized to receive this for the intended recipient, any use, dissemination, distribution, retention, archiving, or copying of this communication is strictly prohibited. If you have received this e-mail in error, please notify the sender immediately by reply e-mail and delete this message.","msg_date":"Mon, 7 Sep 2015 23:33:08 +0500","msg_from":"Ahsan Hadi <ahsan.hadi@enterprisedb.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Thu, Sep 3, 2015 at 7:03 AM, Josh Berkus <josh@agliodbs.com> wrote:\n\n> On 09/02/2015 11:41 AM, Robert Haas wrote:\n> > 4. Therefore, I think that we should instead use logical replication,\n> > which might be either synchronous or asynchronous. When you modify\n> > one copy of the data, that change will then be replicated to all other\n> > nodes. If you are OK with eventual consistency, this replication can\n> > be asynchronous, and nodes that are off-line will catch up when they\n> > are on-line. If you are not OK with that, then you must replicate\n> > synchronously to every node before transaction commit; or at least you\n> > must replicate synchronously to every node that is currently on-line.\n> > This presents some challenges: logical decoding currently can't\n> > replicate transactions that are still in process - replication starts\n> > when the transaction commits. Also, we don't have any way for\n> > synchronous replication to wait for multiple nodes.\n>\n> Well, there is a WIP patch for that, which IMHO would be much improved\n> by having a concrete use-case like this one. What nobody is working on\n> -- and we've vetoed in the past -- is a way of automatically failing and\n> removing from replication any node which repeatedly fails to sync, which\n> would be a requirement for this model.\n>\n> You'd also need a way to let the connection nodes know when a replica\n> has fallen behind so that they can be taken out of\n> load-balancing/sharding for read queries. For the synchronous model,\n> that would be \"fallen behind at all\"; for asynchronous it would be\n> \"fallen more than ### behind\".\n>\n\nI have been thinking about that problem in the context of\nsynchronous_commit = apply, and while trying to review the multiple\nsynchronous patch. How are you supposed to actually make use of\nremote-apply semantics without a way to find a replica that is consistent?\nAnd what does consistent mean? I'm going to say consistency means: it sees\nat least all effects of all preceding COMMITs that returned successfully.\nIt's trivial in a no-timeout, single standby topology (if commit returned,\nthe sole sync replica has applied your transaction and replied), but beyond\nthat it obviously requires some more infrastructure and concepts. Here is\nmy suggestion:\n\nImagine if we could configure setups like this:\n\n1. I have 4 servers called london1, london2, paris1, paris2 (see nearby\nmultiple sync server thread/patch).\n2. I have synchronous_commit = apply (see nearby thread/patch)\n3. Currently london1 is master, with the other 3 in the synchronous\nreplication set, and I want a minimum replication set of size 2 so I can\nlose 1 of those and continue\n\nSo far so good, now for the double-vapourware part:\n\n4. The replicas know whether they are currently part of the master's\nsynchronous replication set or not because it tells them\n5. While waiting for replicas, the master only waits up to X milliseconds,\nand if no reply is received from a given server it drops that server from\nthe sync rep set, like a RAID controller dropping an unresponsive element\nfrom a RAID array, but still returns control to the user if 2 nodes (our\nconfigured minimum) did reply\n6. If the sync rep set reaches our minimum size 2 because of a node being\ndropped, then you can no longer drop one, so commit hangs (work is blocked\nuntil enough servers connect and catch up again)\n7. If a replica sees that it hasn't received WAL records or pings from the\nmaster with timestamps from the past Y milliseconds, or receives a message\nexplicitly telling it it's been dropped from the sync rep set, it will\nstart rejecting my queries on the basis that it's potentially out of date\n8. If the master sees suitable apply reply messages stream in from a node\nthat was dropped but has now caught up (possibly having reconnected), it\nwill explicitly tell it that it's back in the sync rep set and start\nwaiting for it again\n9. X is sufficiently larger than Y so that, combined with the 'you've been\ndropped from/rejoined the sync rep set' messages and well sync'd system\nclocks, it should not be possible for a replica to expose snapshots that\ndon't include all effects from transactions whose COMMIT command returned\non the master. (If you don't have the concept of a dynamic replication set\nwhich replicas are dropped from and rejoin, then the master can't drop a\nnode and carry on, like a RAID controller would, unless it's happy to wait\nfor any old N nodes to reply. Waiting for any N nodes to reply may be OK\nfor log-flush-only sync rep, but if you want to use apply sync rep and have\nguarantees about visibility, and you simply wait for any N nodes to reply,\nthen the nodes themselves don't know if they are up to date with master or\nnot (they don't know if they were one of the ones that master waited for\nsome transaction they haven't even heard about yet), so they may show users\nold data. Also, if you don't have the master telling the replicas that it\nconsiders them to be in or out of the replication set, they don't know\nexactly when the master decides to consider them in again after they\nrejoin.)\n\nNow I can connect to any server and specify my requirement to see all\ncommitted-on-the-master transactions (meaning: the COMMIT command returned\nsuccess to the client), and either get an error telling me that it can't\nguarantee that at that moment (because it has been told it's not in the\nsync rep set or hasn't heard from the master recently enough), or happily\nproceed to query the database. I can send my writes to the master node,\nand do all my reads on any node I like, and be sure they include whatever I\njust committed (or someone else just committed and told me about). I can\nalso use FDW to query the replicas from the master and know that they can\nsee everything already committed (but of course not uncommitted changes;\nI'm guessing you get that on the GTM based systems).\n\nThe main problem I can see so far with this scheme is that you can see\nthings on the replicas *before* the COMMIT returns. Is that a problem? I\nsuspect all solutions to that problem involve centralised snapshot control\n(through a GTM or through the master).\n\nThe timeout and ping based drop/join idea is inspired by a non-Postgres\nsystem that was presented at CHAR(14) last year that is due to be released\nas open source one day (and whose author egged me on to try implementing\nthat synchronous_commit = apply patch), and I guess loosely RAID. Maybe\nthere is better terminology or a name in database literature for this\napproach, I'm not sure, and maybe it has unacceptable holes. It's a lot\nless radical than the GTM/MPP systems, since it just adds a few bells and\nwhistles to the existing single master replication model, and obviously\nthere are plenty more problems to solve to make really useful clustering\ntechnology, like master reelection, query routing/node location, load\nbalancing and so forth. But the master and the replicas have the\ninformation they need to do that.\n\n-- \nThomas Munro\nhttp://www.enterprisedb.com\n\nOn Thu, Sep 3, 2015 at 7:03 AM, Josh Berkus <josh@agliodbs.com> wrote:On 09/02/2015 11:41 AM, Robert Haas wrote:\n> 4. Therefore, I think that we should instead use logical replication,\n> which might be either synchronous or asynchronous. When you modify\n> one copy of the data, that change will then be replicated to all other\n> nodes. If you are OK with eventual consistency, this replication can\n> be asynchronous, and nodes that are off-line will catch up when they\n> are on-line. If you are not OK with that, then you must replicate\n> synchronously to every node before transaction commit; or at least you\n> must replicate synchronously to every node that is currently on-line.\n> This presents some challenges: logical decoding currently can't\n> replicate transactions that are still in process - replication starts\n> when the transaction commits. Also, we don't have any way for\n> synchronous replication to wait for multiple nodes.\n\nWell, there is a WIP patch for that, which IMHO would be much improved\nby having a concrete use-case like this one. What nobody is working on\n-- and we've vetoed in the past -- is a way of automatically failing and\nremoving from replication any node which repeatedly fails to sync, which\nwould be a requirement for this model.\n\nYou'd also need a way to let the connection nodes know when a replica\nhas fallen behind so that they can be taken out of\nload-balancing/sharding for read queries. For the synchronous model,\nthat would be \"fallen behind at all\"; for asynchronous it would be\n\"fallen more than ### behind\".I have been thinking about that problem in the context of synchronous_commit = apply, and while trying to review the multiple synchronous patch. How are you supposed to actually make use of remote-apply semantics without a way to find a replica that is consistent? And what does consistent mean? I'm going to say consistency means: it sees at least all effects of all preceding COMMITs that returned successfully. It's trivial in a no-timeout, single standby topology (if commit returned, the sole sync replica has applied your transaction and replied), but beyond that it obviously requires some more infrastructure and concepts. Here is my suggestion:Imagine if we could configure setups like this:1. I have 4 servers called london1, london2, paris1, paris2 (see nearby multiple sync server thread/patch).2. I have synchronous_commit = apply (see nearby thread/patch)3. Currently london1 is master, with the other 3 in the synchronous replication set, and I want a minimum replication set of size 2 so I can lose 1 of those and continueSo far so good, now for the double-vapourware part:4. The replicas know whether they are currently part of the master's synchronous replication set or not because it tells them5. While waiting for replicas, the master only waits up to X milliseconds, and if no reply is received from a given server it drops that server from the sync rep set, like a RAID controller dropping an unresponsive element from a RAID array, but still returns control to the user if 2 nodes (our configured minimum) did reply6. If the sync rep set reaches our minimum size 2 because of a node being dropped, then you can no longer drop one, so commit hangs (work is blocked until enough servers connect and catch up again)7. If a replica sees that it hasn't received WAL records or pings from the master with timestamps from the past Y milliseconds, or receives a message explicitly telling it it's been dropped from the sync rep set, it will start rejecting my queries on the basis that it's potentially out of date8. If the master sees suitable apply reply messages stream in from a node that was dropped but has now caught up (possibly having reconnected), it will explicitly tell it that it's back in the sync rep set and start waiting for it again9. X is sufficiently larger than Y so that, combined with the 'you've been dropped from/rejoined the sync rep set' messages and well sync'd system clocks, it should not be possible for a replica to expose snapshots that don't include all effects from transactions whose COMMIT command returned on the master. (If you don't have the concept of a dynamic replication set which replicas are dropped from and rejoin, then the master can't drop a node and carry on, like a RAID controller would, unless it's happy to wait for any old N nodes to reply. Waiting for any N nodes to reply may be OK for log-flush-only sync rep, but if you want to use apply sync rep and have guarantees about visibility, and you simply wait for any N nodes to reply, then the nodes themselves don't know if they are up to date with master or not (they don't know if they were one of the ones that master waited for some transaction they haven't even heard about yet), so they may show users old data. Also, if you don't have the master telling the replicas that it considers them to be in or out of the replication set, they don't know exactly when the master decides to consider them in again after they rejoin.)Now I can connect to any server and specify my requirement to see all committed-on-the-master transactions (meaning: the COMMIT command returned success to the client), and either get an error telling me that it can't guarantee that at that moment (because it has been told it's not in the sync rep set or hasn't heard from the master recently enough), or happily proceed to query the database. I can send my writes to the master node, and do all my reads on any node I like, and be sure they include whatever I just committed (or someone else just committed and told me about). I can also use FDW to query the replicas from the master and know that they can see everything already committed (but of course not uncommitted changes; I'm guessing you get that on the GTM based systems).The main problem I can see so far with this scheme is that you can see things on the replicas *before* the COMMIT returns. Is that a problem? I suspect all solutions to that problem involve centralised snapshot control (through a GTM or through the master).The timeout and ping based drop/join idea is inspired by a non-Postgres system that was presented at CHAR(14) last year that is due to be released as open source one day (and whose author egged me on to try implementing that synchronous_commit = apply patch), and I guess loosely RAID. Maybe there is better terminology or a name in database literature for this approach, I'm not sure, and maybe it has unacceptable holes. It's a lot less radical than the GTM/MPP systems, since it just adds a few bells and whistles to the existing single master replication model, and obviously there are plenty more problems to solve to make really useful clustering technology, like master reelection, query routing/node location, load balancing and so forth. But the master and the replicas have the information they need to do that.-- Thomas Munrohttp://www.enterprisedb.com","msg_date":"Tue, 8 Sep 2015 18:25:00 +1200","msg_from":"Thomas Munro <thomas.munro@enterprisedb.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Fri, Sep 4, 2015 at 6:52 PM, Ozgun Erdogan <ozgun@citusdata.com> wrote:\n> Distributed shuffles (Map/Reduce) are hard. When we looked at using FDWs for\n> pg_shard, we thought that Map/Reduce would require a comprehensive revamp of\n> the APIs.\n\nWell, so you've said. But what kind of API do you want to see?\nTaking control at some very high-level hook like ExecutorRun() is not\nreally a maintainable solution - it's fine if you've only got one guy\ndoing it, perhaps, but if you have several FDWs talking to different\nkinds of remote systems, they can't all seize overall control.\n\n>> For Citus, a second part of the question is as FDW writers. We implemented\n> cstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't benefit from\n> even the simple join pushdown that doesn't require Map/Reduce.\n>\n> The PostgreSQL wiki lists 85 foreign data wrappers, and only 18 of these\n> have support for joins:\n> https://wiki.postgresql.org/wiki/Foreign_data_wrappers\n\nWhat do you mean by \"support for joins\"? Do you mean that only 18 of\nthe remote data sources can do joins? If so, why does that matter?\nI'd be quite happy if a join pushdown or \"distributed shuffle\" API had\nas many as 18 users - I'd be quite happy if it had one (postgres_fdw).\nThe fact that not all FDWs can support every operation because of\nlimitations on the remote side isn't a reason not to support those\noperations when the remote side is capable.\n\n-- \nRobert Haas\nEnterpriseDB: http://www.enterprisedb.com\nThe Enterprise PostgreSQL Company\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 8 Sep 2015 13:52:52 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On 2015-09-08 19:52, Robert Haas wrote:\n> On Fri, Sep 4, 2015 at 6:52 PM, Ozgun Erdogan <ozgun@citusdata.com> wrote:\n>>> For Citus, a second part of the question is as FDW writers. We implemented\n>> cstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't benefit from\n>> even the simple join pushdown that doesn't require Map/Reduce.\n>>\n>> The PostgreSQL wiki lists 85 foreign data wrappers, and only 18 of these\n>> have support for joins:\n>> https://wiki.postgresql.org/wiki/Foreign_data_wrappers\n>\n> What do you mean by \"support for joins\"? Do you mean that only 18 of\n> the remote data sources can do joins? If so, why does that matter?\n> I'd be quite happy if a join pushdown or \"distributed shuffle\" API had\n> as many as 18 users - I'd be quite happy if it had one (postgres_fdw).\n> The fact that not all FDWs can support every operation because of\n> limitations on the remote side isn't a reason not to support those\n> operations when the remote side is capable.\n>\n\nAgreed. While I personally don't think FDWs are long term answer for \nsharding, I do believe that the infrastructure that is being developed \nfor FDWs (join/aggregate pushdown) is needed anyway and there are many \ncommon issues that need solving in this area for FDWs, sharding and \nparallel query.\n\n-- \n Petr Jelinek http://www.2ndQuadrant.com/\n PostgreSQL Development, 24x7 Support, Training & Services\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 8 Sep 2015 20:40:42 +0200","msg_from":"Petr Jelinek <petr@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"},{"msg_contents":"On Mon, Sep 7, 2015 at 1:33 PM, Ahsan Hadi <ahsan.hadi@enterprisedb.com> wrote:\n> I\n>\n> On Monday, September 7, 2015, Ashutosh Bapat\n> <ashutosh.bapat@enterprisedb.com> wrote:\n>>\n>>\n>>\n>> On Sat, Sep 5, 2015 at 4:22 AM, Ozgun Erdogan <ozgun@citusdata.com> wrote:\n>>>\n>>> Hey Robert,\n>>>\n>>>> Now the question is, where should the code that does all of this live?\n>>>> postgres_fdw? Some new, sharding-specific FDW? In core? I don't\n>>>> know for sure, but what I do know is that we could make a lot of\n>>>> progress over where we are today by just improving postgres_fdw, and I\n>>>> don't think those improvements are even all that difficult. If we\n>>>> decide we need to implement something new, it's going to be a huge\n>>>> project that will take years to complete, with uncertain results. I'd\n>>>> rather have a postgres_fdw-based implementation that is imperfect and\n>>>> can't handle some kinds of queries in 9.6 than a promise that by 9.9\n>>>> we'll have something really great that handles MPP perfectly.\n>>>\n>>>\n>>> Distributed shuffles (Map/Reduce) are hard. When we looked at using FDWs\n>>> for pg_shard, we thought that Map/Reduce would require a comprehensive\n>>> revamp of the APIs.\n>>>\n>>> For Citus, a second part of the question is as FDW writers. We\n>>> implemented cstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't\n>>> benefit from even the simple join pushdown that doesn't require Map/Reduce.\n>>\n>>\n>> I didn't get this. Join pushdown infrastructure (chiefly set of hooks\n>> provided in join planning paths) is part of 9.5. Isn't that sufficient to\n>> implement join push-down for above FDWs? Or FDW writers are facing problems\n>> while implementing those hooks. In either case that should be reported on\n>> hackers.\n>>\n>\n>\n> I don't think any FDW writer (other the postgres_fdw) has tried to implement\n> join push down in the respective FDW's using the new API.\n\nWell, 'jdbc_fdw2' seems to implement deparsing at some level:\nhttps://github.com/heimir-sverrisson/jdbc2_fdw/blob/master/deparse.c\n\n...but this was likely a copy/paste job from the postgres_fdw. It\nshould not escape note that the deparsing strategy has dependencies on\nthe optimizer and the parser. This is not good; asking the FDW\nimplementations to implement SQL optimizations is not a sustainable\nsolution. They should be indicating, for example, \"I support ANSI-92\nSQL\", and the postgres planner should be deparsing the foreign table\ndefinition and rewriting it, not the other way around.\n\nmerlin\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Tue, 8 Sep 2015 13:56:37 -0500","msg_from":"Merlin Moncure <mmoncure@gmail.com>","msg_from_op":false,"msg_subject":"Re: Horizontal scalability/sharding"}],"string":"[\n {\n \"msg_contents\": \"I have recently increased my public statements about the idea of adding\\nhorizontal scaling/sharding to Postgres. I wanted to share with hackers\\na timeline of how we got here, and where I think we are going in the\\nshort term:\\n\\n2012-2013: As part of writing my scaling talk\\n(http://momjian.us/main/presentations/overview.html#scaling), studying\\nOracle RAC, and talking to users, it became clear that an XC-like\\narchitecture (sharding) was the only architecture that was going to allow\\nfor write scaling.\\n\\nUsers and conference attendees I talked to were increasingly concerned\\nabout the ability of Postgres to scale for high write volumes. They didn't\\nnecessarily need that scale now, but they needed to know they could get\\nit if they wanted it, and wouldn't need to switch to a new database in\\nthe future. This is similar to wanting a car that can get you on a highway\\non-ramp fast --- even if you don't need it, you want to know it is there.\\n\\n2014: I started to shop around the idea that we could use FDWs,\\nparallelism, and a transaction/snapshot manager to get XC features\\nas built-in to Postgres. (I don't remember where the original idea\\ncame from.) It was clear that having separate forks of the source code\\nin XC and XL was never going to achieve critical mass --- there just\\naren't enough people who need high right scale right now, and the fork\\nmaintenance overhead is a huge burden.\\n\\nI realized that we would never get community acceptance to dump the XC\\n(or XL) code needed for sharding into community Postgres, but with FDWs,\\nwe could add the features as _part_ of improving FDWs, which would benefit\\nFDWs _and_ would be useful for sharding. (We already see some of those\\nFDW features in 9.5.)\\n\\nOctober, 2014: EDB and NTT started working together in the community\\nto start improving FDWs as a basis for an FDW-based sharding solution.\\nMany of the 9.5 FDW improvements that also benefit sharding were developed\\nby a combined EDB/NTT team. The features improved FDWs independent of\\nsharding, so they didn't need community buy-in on sharding to get them\\naccepted.\\n\\nJune, 2015: I attended the PGCon sharding unconference session and\\nthere was a huge discussion about where we should go with sharding.\\nI think the big take-away was that most people liked the FDW approach,\\nbut had business/customer reasons for wanting to work on XC or XL because\\nthose would be production-ready faster.\\n\\nJuly, 2015: Oleg Bartunov and his new company Postgres Professional (PP)\\nstarted to think about joining the FDW approach, rather than working on\\nXL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\\nmeeting is scheduled for September 1.\\n\\nAugust, 2015: While speaking at SFPUG, Citus Data approached me about\\njoining the FDW sharding team. They have been invited to the September\\n1 meeting, as have the XC and XL people.\\n\\nOctober, 2015: EDB is sponsoring a free 3-hour summit about FDW sharding\\nat the PG-EU conference in Vienna. Everyone is invited, but it is hoped\\nmost of the September 1 folks can attend.\\n\\nFebruary, 2016: Oleg is planning a similar meeting at their February\\nMoscow conference.\\n\\nAnyway, I wanted to explain the work that has been happening around\\nsharding. As things move forward, I am increasingly convinced that write\\nscaling will be needed soon, that the XC approach is the only reasonable\\nway to do it, and that FDWs are the cleanest way to get it into community\\nPostgres.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sat, 29 Aug 2015 22:17:58 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 30 August 2015 at 03:17, Bruce Momjian <bruce@momjian.us> wrote:\\n\\n> I have recently increased my public statements about the idea of adding\\n> horizontal scaling/sharding to Postgres.\\n\\n\\nGlad to see it. Many people have been pushing such things for years, so it\\nis good to finally see some debate about this on Hackers.\\n\\n\\n> I wanted to share with hackers\\n> a timeline of how we got here, and where I think we are going in the\\n> short term:\\n>\\n> 2012-2013: As part of writing my scaling talk\\n> (http://momjian.us/main/presentations/overview.html#scaling), studying\\n> Oracle RAC, and talking to users, it became clear that an XC-like\\n> architecture (sharding) was the only architecture that was going to allow\\n> for write scaling.\\n>\\n\\nWhat other architectures were discussed? Where was that discussion?\\n\\n\\n> Users and conference attendees I talked to were increasingly concerned\\n> about the ability of Postgres to scale for high write volumes. They didn't\\n> necessarily need that scale now, but they needed to know they could get\\n> it if they wanted it, and wouldn't need to switch to a new database in\\n> the future. This is similar to wanting a car that can get you on a highway\\n> on-ramp fast --- even if you don't need it, you want to know it is there.\\n>\\n\\n+1\\n\\n\\n> 2014: I started to shop around the idea that we could use FDWs,\\n> parallelism, and a transaction/snapshot manager to get XC features\\n> as built-in to Postgres. (I don't remember where the original idea\\n> came from.) It was clear that having separate forks of the source code\\n> in XC and XL was never going to achieve critical mass --- there just\\n> aren't enough people who need high right scale right now, and the fork\\n> maintenance overhead is a huge burden.\\n>\\n\\nI personally support the view that we should put scalability features into\\nPostgres core, rather than run separate forks.\\n\\n\\n> I realized that we would never get community acceptance to dump the XC\\n> (or XL) code needed for sharding into community Postgres\\n\\n\\nHow or why did you realize that? There has never been any such discussion,\\nAFAIK. Surely it can be possible to move required subsystems across?\\n\\n\\n> , but with FDWs,\\n> we could add the features as _part_ of improving FDWs, which would benefit\\n> FDWs _and_ would be useful for sharding. (We already see some of those\\n> FDW features in 9.5.)\\n>\\n\\nThat is a huge presumption. Not discussed or technically analyzed in any\\nway with the community.\\n\\n\\n> October, 2014: EDB and NTT started working together in the community\\n> to start improving FDWs as a basis for an FDW-based sharding solution.\\n> Many of the 9.5 FDW improvements that also benefit sharding were developed\\n> by a combined EDB/NTT team. The features improved FDWs independent of\\n> sharding, so they didn't need community buy-in on sharding to get them\\n> accepted.\\n>\\n> June, 2015: I attended the PGCon sharding unconference session and\\n> there was a huge discussion about where we should go with sharding.\\n> I think the big take-away was that most people liked the FDW approach,\\n> but had business/customer reasons for wanting to work on XC or XL because\\n> those would be production-ready faster.\\n>\\n\\nCough, cough. You must surely be joking that \\\"most people liked the FDW\\napproach\\\"? How did we measure the acceptance of this approach?\\n\\nWhat actually is the FDW approach? Since its not been written down\\nanywhere, or even explained verbally, how can anyone actually agree to it?\\n\\n\\n> July, 2015: Oleg Bartunov and his new company Postgres Professional (PP)\\n> started to think about joining the FDW approach, rather than working on\\n> XL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\\n> meeting is scheduled for September 1.\\n>\\n\\n\\n> August, 2015: While speaking at SFPUG, Citus Data approached me about\\n> joining the FDW sharding team. They have been invited to the September\\n> 1 meeting, as have the XC and XL people.\\n>\\n\\n2ndQuadrant is working in this area, specifically bringing XL 9.5 forwards.\\nPlease can invites be posted to myself, Pavan Deolasee and Petr Jelinek\\nalso? I'll pass on to others also.\\n\\nKoichi Suzuki is arranging a meeting in Hong Long for XC/XL discussions.\\nPresumably EDB is invited also? If Koichi is a leading organizer of this,\\nwhy are there two meetings?\\n\\nOctober, 2015: EDB is sponsoring a free 3-hour summit about FDW sharding\\n> at the PG-EU conference in Vienna. Everyone is invited, but it is hoped\\n> most of the September 1 folks can attend.\\n>\\n\\n\\n> February, 2016: Oleg is planning a similar meeting at their February\\n> Moscow conference.\\n>\\n\\n\\n> Anyway, I wanted to explain the work that has been happening around\\n> sharding.\\n\\n\\nThanks\\n\\n\\n> As things move forward, I am increasingly convinced that write\\n> scaling will be needed soon,\\n\\n\\n+1\\n\\n\\n> that the XC approach is the only reasonable way to do it,\\n\\n\\n\\n> and that FDWs are the cleanest way to get it into community\\n> Postgres.\\n>\\n\\nThose two things aren't at all obvious to me.\\n\\nPlease don't presume my opposition. If the technical information were made\\npublic, I might understand and agree with \\\"the FDW approach\\\", perhaps\\nothers also. 2ndQuadrant is certainly happy to become involved in any team\\naiming to add features to Postgres core, as long as that makes sense. There\\nmay be areas we can all agree upon even if the full architecture remains in\\ndoubt.\\n\\nBefore the community commits to a long term venture together we should see\\nthe plan. Like all IT projects, expensive failure is possible and the lack\\nof a design is a huge flashing red warning light for me at present. If that\\nrequires a meeting of all Developers, why are the meetings for this\\nspecifically not happening at the agreed Developer meetings?\\n\\n-- \\nSimon Riggs http://www.2ndQuadrant.com/\\n<http://www.2ndquadrant.com/>\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\nOn 30 August 2015 at 03:17, Bruce Momjian <bruce@momjian.us> wrote:I have recently increased my public statements about the idea of adding\\nhorizontal scaling/sharding to Postgres. Glad to see it. Many people have been pushing such things for years, so it is good to finally see some debate about this on Hackers. I wanted to share with hackers\\na timeline of how we got here, and where I think we are going in the\\nshort term:\\n\\n2012-2013: As part of writing my scaling talk\\n(http://momjian.us/main/presentations/overview.html#scaling), studying\\nOracle RAC, and talking to users, it became clear that an XC-like\\narchitecture (sharding) was the only architecture that was going to allow\\nfor write scaling.What other architectures were discussed? Where was that discussion? \\nUsers and conference attendees I talked to were increasingly concerned\\nabout the ability of Postgres to scale for high write volumes. They didn't\\nnecessarily need that scale now, but they needed to know they could get\\nit if they wanted it, and wouldn't need to switch to a new database in\\nthe future. This is similar to wanting a car that can get you on a highway\\non-ramp fast --- even if you don't need it, you want to know it is there.+1 \\n2014: I started to shop around the idea that we could use FDWs,\\nparallelism, and a transaction/snapshot manager to get XC features\\nas built-in to Postgres. (I don't remember where the original idea\\ncame from.) It was clear that having separate forks of the source code\\nin XC and XL was never going to achieve critical mass --- there just\\naren't enough people who need high right scale right now, and the fork\\nmaintenance overhead is a huge burden.I personally support the view that we should put scalability features into Postgres core, rather than run separate forks. \\nI realized that we would never get community acceptance to dump the XC\\n(or XL) code needed for sharding into community PostgresHow or why did you realize that? There has never been any such discussion, AFAIK. Surely it can be possible to move required subsystems across? , but with FDWs,\\nwe could add the features as _part_ of improving FDWs, which would benefit\\nFDWs _and_ would be useful for sharding. (We already see some of those\\nFDW features in 9.5.)That is a huge presumption. Not discussed or technically analyzed in any way with the community. \\nOctober, 2014: EDB and NTT started working together in the community\\nto start improving FDWs as a basis for an FDW-based sharding solution.\\nMany of the 9.5 FDW improvements that also benefit sharding were developed\\nby a combined EDB/NTT team. The features improved FDWs independent of\\nsharding, so they didn't need community buy-in on sharding to get them\\naccepted.\\n\\nJune, 2015: I attended the PGCon sharding unconference session and\\nthere was a huge discussion about where we should go with sharding.\\nI think the big take-away was that most people liked the FDW approach,\\nbut had business/customer reasons for wanting to work on XC or XL because\\nthose would be production-ready faster.Cough, cough. You must surely be joking that \\\"most people liked the FDW approach\\\"? How did we measure the acceptance of this approach? What actually is the FDW approach? Since its not been written down anywhere, or even explained verbally, how can anyone actually agree to it? \\nJuly, 2015: Oleg Bartunov and his new company Postgres Professional (PP)\\nstarted to think about joining the FDW approach, rather than working on\\nXL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\\nmeeting is scheduled for September 1. \\nAugust, 2015: While speaking at SFPUG, Citus Data approached me about\\njoining the FDW sharding team. They have been invited to the September\\n1 meeting, as have the XC and XL people.2ndQuadrant is working in this area, specifically bringing XL 9.5 forwards. Please can invites be posted to myself, Pavan Deolasee and Petr Jelinek also? I'll pass on to others also.Koichi Suzuki is arranging a meeting in Hong Long for XC/XL discussions. Presumably EDB is invited also? If Koichi is a leading organizer of this, why are there two meetings?\\nOctober, 2015: EDB is sponsoring a free 3-hour summit about FDW sharding\\nat the PG-EU conference in Vienna. Everyone is invited, but it is hoped\\nmost of the September 1 folks can attend. \\nFebruary, 2016: Oleg is planning a similar meeting at their February\\nMoscow conference. \\nAnyway, I wanted to explain the work that has been happening around\\nsharding.Thanks As things move forward, I am increasingly convinced that write\\nscaling will be needed soon,+1 that the XC approach is the only reasonable way to do it, and that FDWs are the cleanest way to get it into community\\nPostgres.Those two things aren't at all obvious to me.Please don't presume my opposition. If the technical information were made public, I might understand and agree with \\\"the FDW approach\\\", perhaps others also. 2ndQuadrant is certainly happy to become involved in any team aiming to add features to Postgres core, as long as that makes sense. There may be areas we can all agree upon even if the full architecture remains in doubt.Before the community commits to a long term venture together we should see the plan. Like all IT projects, expensive failure is possible and the lack of a design is a huge flashing red warning light for me at present. If that requires a meeting of all Developers, why are the meetings for this specifically not happening at the agreed Developer meetings?-- Simon Riggs http://www.2ndQuadrant.com/PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\",\n \"msg_date\": \"Sun, 30 Aug 2015 15:31:10 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndQuadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Sun, Aug 30, 2015 at 5:31 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n\\n> On 30 August 2015 at 03:17, Bruce Momjian <bruce@momjian.us> wrote:\\n>\\n>> I have recently increased my public statements about the idea of adding\\n>> horizontal scaling/sharding to Postgres.\\n>\\n>\\n> Glad to see it. Many people have been pushing such things for years, so it\\n> is good to finally see some debate about this on Hackers.\\n>\\n>\\n>> I wanted to share with hackers\\n>> a timeline of how we got here, and where I think we are going in the\\n>> short term:\\n>>\\n>> 2012-2013: As part of writing my scaling talk\\n>> (http://momjian.us/main/presentations/overview.html#scaling), studying\\n>> Oracle RAC, and talking to users, it became clear that an XC-like\\n>> architecture (sharding) was the only architecture that was going to allow\\n>> for write scaling.\\n>>\\n>\\n> What other architectures were discussed? Where was that discussion?\\n>\\n>\\n>> Users and conference attendees I talked to were increasingly concerned\\n>> about the ability of Postgres to scale for high write volumes. They\\n>> didn't\\n>> necessarily need that scale now, but they needed to know they could get\\n>> it if they wanted it, and wouldn't need to switch to a new database in\\n>> the future. This is similar to wanting a car that can get you on a\\n>> highway\\n>> on-ramp fast --- even if you don't need it, you want to know it is there.\\n>>\\n>\\n> +1\\n>\\n>\\n>> 2014: I started to shop around the idea that we could use FDWs,\\n>> parallelism, and a transaction/snapshot manager to get XC features\\n>> as built-in to Postgres. (I don't remember where the original idea\\n>> came from.) It was clear that having separate forks of the source code\\n>> in XC and XL was never going to achieve critical mass --- there just\\n>> aren't enough people who need high right scale right now, and the fork\\n>> maintenance overhead is a huge burden.\\n>>\\n>\\n> I personally support the view that we should put scalability features into\\n> Postgres core, rather than run separate forks.\\n>\\n>\\n>> I realized that we would never get community acceptance to dump the XC\\n>> (or XL) code needed for sharding into community Postgres\\n>\\n>\\n> How or why did you realize that? There has never been any such discussion,\\n> AFAIK. Surely it can be possible to move required subsystems across?\\n>\\n>\\n>> , but with FDWs,\\n>> we could add the features as _part_ of improving FDWs, which would benefit\\n>> FDWs _and_ would be useful for sharding. (We already see some of those\\n>> FDW features in 9.5.)\\n>>\\n>\\n> That is a huge presumption. Not discussed or technically analyzed in any\\n> way with the community.\\n>\\n>\\n>> October, 2014: EDB and NTT started working together in the community\\n>> to start improving FDWs as a basis for an FDW-based sharding solution.\\n>> Many of the 9.5 FDW improvements that also benefit sharding were developed\\n>> by a combined EDB/NTT team. The features improved FDWs independent of\\n>> sharding, so they didn't need community buy-in on sharding to get them\\n>> accepted.\\n>>\\n>> June, 2015: I attended the PGCon sharding unconference session and\\n>> there was a huge discussion about where we should go with sharding.\\n>> I think the big take-away was that most people liked the FDW approach,\\n>> but had business/customer reasons for wanting to work on XC or XL because\\n>> those would be production-ready faster.\\n>>\\n>\\n> Cough, cough. You must surely be joking that \\\"most people liked the FDW\\n> approach\\\"? How did we measure the acceptance of this approach?\\n>\\n> What actually is the FDW approach? Since its not been written down\\n> anywhere, or even explained verbally, how can anyone actually agree to it?\\n>\\n>\\n>> July, 2015: Oleg Bartunov and his new company Postgres Professional (PP)\\n>> started to think about joining the FDW approach, rather than working on\\n>> XL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\\n>> meeting is scheduled for September 1.\\n>>\\n>\\n>\\n\\nA little correction about Postgres Professional. We are concentrated on\\nidea to have one distributed transaction manager, originally DTM, now we\\nhave better name XTM, which is neutral to actual cluster realization. For\\nexample, we are testing it with XL, ported to 9.4, but we were planning to\\nextend tests to pg_shard, postgres_fdw. My idea was to have at least XTM\\ncommitted to 9.6, so all parties could work on their implementation much\\neasier.\\n\\n\\n\\n> August, 2015: While speaking at SFPUG, Citus Data approached me about\\n>> joining the FDW sharding team. They have been invited to the September\\n>> 1 meeting, as have the XC and XL people.\\n>>\\n>\\n> 2ndQuadrant is working in this area, specifically bringing XL 9.5\\n> forwards. Please can invites be posted to myself, Pavan Deolasee and Petr\\n> Jelinek also? I'll pass on to others also.\\n>\\n> Koichi Suzuki is arranging a meeting in Hong Long for XC/XL discussions.\\n> Presumably EDB is invited also? If Koichi is a leading organizer of this,\\n> why are there two meetings?\\n>\\n> October, 2015: EDB is sponsoring a free 3-hour summit about FDW sharding\\n>> at the PG-EU conference in Vienna. Everyone is invited, but it is hoped\\n>> most of the September 1 folks can attend.\\n>>\\n>\\n>\\n>> February, 2016: Oleg is planning a similar meeting at their February\\n>> Moscow conference.\\n>>\\n>\\n>\\n>> Anyway, I wanted to explain the work that has been happening around\\n>> sharding.\\n>\\n>\\n> Thanks\\n>\\n>\\n>> As things move forward, I am increasingly convinced that write\\n>> scaling will be needed soon,\\n>\\n>\\n> +1\\n>\\n>\\n>> that the XC approach is the only reasonable way to do it,\\n>\\n>\\n>\\n>> and that FDWs are the cleanest way to get it into community\\n>> Postgres.\\n>>\\n>\\n> Those two things aren't at all obvious to me.\\n>\\n> Please don't presume my opposition. If the technical information were made\\n> public, I might understand and agree with \\\"the FDW approach\\\", perhaps\\n> others also. 2ndQuadrant is certainly happy to become involved in any team\\n> aiming to add features to Postgres core, as long as that makes sense. There\\n> may be areas we can all agree upon even if the full architecture remains in\\n> doubt.\\n>\\n> Before the community commits to a long term venture together we should see\\n> the plan. Like all IT projects, expensive failure is possible and the lack\\n> of a design is a huge flashing red warning light for me at present. If that\\n> requires a meeting of all Developers, why are the meetings for this\\n> specifically not happening at the agreed Developer meetings?\\n>\\n>\\nAt PGCon we agreed to have such meeting in Vienna at least. But I think we\\nshould be prepared and try to clean all our issues before. It looks like we\\nalready out of time,but probably we could meet in Hong Kong ?\\n\\nHonestly, I still don't know which approach is better, we already played\\nwith XL (ported to 9.4) and identified some very strong issues with\\ninconsistency, which scared us, especially taking into account how easy we\\nfound them. XC people have fixed them, but I'm not sure if they were\\nfundamental and if we could construct more sophisticated tests and find\\nmore issues in XC/XL. We also a bit disappointed by Huawei position about\\nCSN patch, we hoped to use for our XTM. FDW approach has been actively\\ncriticized by pg_shard people and that's also made me a bit suspicious. It\\nlooks like we are doomed to continue several development forks, so we\\ndecided to work on very important common project, XTM, which we hoped could\\nbe accepted by all parties and eventually committed to 9.6. Now I see we\\nwere right, unfortunately.\\n\\nAgain, could we organize meeting somewhere in September ? US is not good\\nfor us, but other places should be ok. I want to have an agreement at\\nleast on XTM. We still are testing various approaches, though. We could\\npresent results of our experiments and are open to discussion. It's not\\neasy project, but it's something we could do for 9.6.\\n\\nI'm very glad Bruce started this discussion in -hackers, since it's silly\\nto me to participate in both threads :) Let's meet in September !\\n\\n\\n\\n> --\\n> Simon Riggs http://www.2ndQuadrant.com/\\n> <http://www.2ndquadrant.com/>\\n> PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n>\\n\\nOn Sun, Aug 30, 2015 at 5:31 PM, Simon Riggs <simon@2ndquadrant.com> wrote:On 30 August 2015 at 03:17, Bruce Momjian <bruce@momjian.us> wrote:I have recently increased my public statements about the idea of adding\\nhorizontal scaling/sharding to Postgres. Glad to see it. Many people have been pushing such things for years, so it is good to finally see some debate about this on Hackers. I wanted to share with hackers\\na timeline of how we got here, and where I think we are going in the\\nshort term:\\n\\n2012-2013: As part of writing my scaling talk\\n(http://momjian.us/main/presentations/overview.html#scaling), studying\\nOracle RAC, and talking to users, it became clear that an XC-like\\narchitecture (sharding) was the only architecture that was going to allow\\nfor write scaling.What other architectures were discussed? Where was that discussion? \\nUsers and conference attendees I talked to were increasingly concerned\\nabout the ability of Postgres to scale for high write volumes. They didn't\\nnecessarily need that scale now, but they needed to know they could get\\nit if they wanted it, and wouldn't need to switch to a new database in\\nthe future. This is similar to wanting a car that can get you on a highway\\non-ramp fast --- even if you don't need it, you want to know it is there.+1 \\n2014: I started to shop around the idea that we could use FDWs,\\nparallelism, and a transaction/snapshot manager to get XC features\\nas built-in to Postgres. (I don't remember where the original idea\\ncame from.) It was clear that having separate forks of the source code\\nin XC and XL was never going to achieve critical mass --- there just\\naren't enough people who need high right scale right now, and the fork\\nmaintenance overhead is a huge burden.I personally support the view that we should put scalability features into Postgres core, rather than run separate forks. \\nI realized that we would never get community acceptance to dump the XC\\n(or XL) code needed for sharding into community PostgresHow or why did you realize that? There has never been any such discussion, AFAIK. Surely it can be possible to move required subsystems across? , but with FDWs,\\nwe could add the features as _part_ of improving FDWs, which would benefit\\nFDWs _and_ would be useful for sharding. (We already see some of those\\nFDW features in 9.5.)That is a huge presumption. Not discussed or technically analyzed in any way with the community. \\nOctober, 2014: EDB and NTT started working together in the community\\nto start improving FDWs as a basis for an FDW-based sharding solution.\\nMany of the 9.5 FDW improvements that also benefit sharding were developed\\nby a combined EDB/NTT team. The features improved FDWs independent of\\nsharding, so they didn't need community buy-in on sharding to get them\\naccepted.\\n\\nJune, 2015: I attended the PGCon sharding unconference session and\\nthere was a huge discussion about where we should go with sharding.\\nI think the big take-away was that most people liked the FDW approach,\\nbut had business/customer reasons for wanting to work on XC or XL because\\nthose would be production-ready faster.Cough, cough. You must surely be joking that \\\"most people liked the FDW approach\\\"? How did we measure the acceptance of this approach? What actually is the FDW approach? Since its not been written down anywhere, or even explained verbally, how can anyone actually agree to it? \\nJuly, 2015: Oleg Bartunov and his new company Postgres Professional (PP)\\nstarted to think about joining the FDW approach, rather than working on\\nXL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\\nmeeting is scheduled for September 1. A little correction about Postgres Professional. We are concentrated on \\nidea to have one distributed transaction manager, originally DTM, now we\\n have better name XTM, which is neutral to actual cluster realization. \\nFor example, we are testing it with XL, ported to 9.4, but we were \\nplanning to extend tests to pg_shard, postgres_fdw. My idea was to have \\nat least XTM committed to 9.6, so all parties could work on their \\nimplementation much easier. \\nAugust, 2015: While speaking at SFPUG, Citus Data approached me about\\njoining the FDW sharding team. They have been invited to the September\\n1 meeting, as have the XC and XL people.2ndQuadrant is working in this area, specifically bringing XL 9.5 forwards. Please can invites be posted to myself, Pavan Deolasee and Petr Jelinek also? I'll pass on to others also.Koichi Suzuki is arranging a meeting in Hong Long for XC/XL discussions. Presumably EDB is invited also? If Koichi is a leading organizer of this, why are there two meetings?\\nOctober, 2015: EDB is sponsoring a free 3-hour summit about FDW sharding\\nat the PG-EU conference in Vienna. Everyone is invited, but it is hoped\\nmost of the September 1 folks can attend. \\nFebruary, 2016: Oleg is planning a similar meeting at their February\\nMoscow conference. \\nAnyway, I wanted to explain the work that has been happening around\\nsharding.Thanks As things move forward, I am increasingly convinced that write\\nscaling will be needed soon,+1 that the XC approach is the only reasonable way to do it, and that FDWs are the cleanest way to get it into community\\nPostgres.Those two things aren't at all obvious to me.Please don't presume my opposition. If the technical information were made public, I might understand and agree with \\\"the FDW approach\\\", perhaps others also. 2ndQuadrant is certainly happy to become involved in any team aiming to add features to Postgres core, as long as that makes sense. There may be areas we can all agree upon even if the full architecture remains in doubt.Before the community commits to a long term venture together we should see the plan. Like all IT projects, expensive failure is possible and the lack of a design is a huge flashing red warning light for me at present. If that requires a meeting of all Developers, why are the meetings for this specifically not happening at the agreed Developer meetings?At PGCon we agreed to have such meeting in Vienna at least. But I think we should be prepared and try to clean all our issues before. It looks like we already out of time,but probably we could meet in Hong Kong ? Honestly, I still don't know which approach is better, we already played with XL (ported to 9.4) and identified some very strong issues with inconsistency, which scared us, especially taking into account how easy we found them. XC people have fixed them, but I'm not sure if they were fundamental and if we could construct more sophisticated tests and find more issues in XC/XL. We also a bit disappointed by Huawei position about CSN patch, we hoped to use for our XTM. FDW approach has been actively criticized by pg_shard people and that's also made me a bit suspicious. It looks like we are doomed to continue several development forks, so we decided to work on very important common project, XTM, which we hoped could be accepted by all parties and eventually committed to 9.6. Now I see we were right, unfortunately. Again, could we organize meeting somewhere in September ? US is not good for us, but other places should be ok. I want to have an agreement at least on XTM. We still are testing various approaches, though. We could present results of our experiments and are open to discussion. It's not easy project, but it's something we could do for 9.6.I'm very glad Bruce started this discussion in -hackers, since it's silly to me to participate in both threads :) Let's meet in September ! -- Simon Riggs http://www.2ndQuadrant.com/PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\",\n \"msg_date\": \"Sun, 30 Aug 2015 22:36:23 +0300\",\n \"msg_from\": \"Oleg Bartunov <obartunov@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Sun, Aug 30, 2015 at 03:31:10PM +0100, Simon Riggs wrote:\\n> On 30 August 2015 at 03:17, Bruce Momjian <bruce@momjian.us> wrote:\\n> \\n> I have recently increased my public statements about the idea of adding\\n> horizontal scaling/sharding to Postgres.\\n>\\n> Glad to see it. Many people have been pushing such things for years, so it is\\n> good to finally see some debate about this on Hackers.\\n\\nAgreed. Right now, in our community, we are only seeing users who are\\nhappy with what Postgres offers but think they might need massive\\nhorizontal scalability in the future. I think there is a larger group\\nthat cares about massive horizontal scalability, but those people are\\nusing other software right now, so we don't see them yet.\\n\\nWithout a roadmap for built-in massive horizontal scalability, I think\\nPostgres adoption will eventually suffer.\\n\\n> I wanted to share with hackers\\n> a timeline of how we got here, and where I think we are going in the\\n> short term:\\n> \\n> 2012-2013:� As part of writing my scaling talk\\n> (http://momjian.us/main/presentations/overview.html#scaling), studying\\n> Oracle RAC, and talking to users, it became clear that an XC-like\\n> architecture (sharding) was the only architecture that was going to allow\\n> for write scaling.\\n> \\n> \\n> What other architectures were discussed? Where was that discussion?\\n\\nThat was mostly my conclusion. I explained it to small groups at\\nconferences and Postgres user groups. No one said I was wrong, but that\\nis about the level of debate I had.\\n\\n> 2014:� I started to shop around the idea that we could use FDWs,\\n> parallelism, and a transaction/snapshot manager to get XC features\\n> as built-in to Postgres.� (I don't remember where the original idea\\n> came from.)� It was clear that having separate forks of the source code\\n> in XC and XL was never going to achieve critical mass --- there just\\n> aren't enough people who need high right scale right now, and the fork\\n> maintenance overhead is a huge burden.\\n> \\n> \\n> I personally support the view that we should put scalability features into\\n> Postgres core, rather than run separate forks.\\n\\nGood, I do think it is time, but as I stated above, there is limited\\ninterest in our current community, so the tolerance for additional\\ncommunity code to accomplish this is also limited. This is the big\\nthing that had me excited about using FDWs --- FDW improvements can get\\nus closer to sharding without requiring community acceptance of\\nsharding-only features.\\n\\n> I realized that we would never get community acceptance to dump the XC\\n> (or XL) code needed for sharding into community Postgres\\n> \\n> \\n> How or why did you realize that? There has never been any such discussion,\\n> AFAIK. Surely it can be possible to move required subsystems across?\\n\\nWell, I have had many such discussions with XC/XL folks, and that was my\\nopinion. I have seen almost no public discussion about this because the\\nidea had almost no chance of success. If it was possible, someone would\\nhave already suggested it on this list.\\n\\n> , but with FDWs,\\n> we could add the features as _part_ of improving FDWs, which would benefit\\n> FDWs _and_ would be useful for sharding.� (We already see some of those\\n> FDW features in 9.5.)\\n> \\n> \\n> That is a huge presumption. Not discussed or technically analyzed in any way\\n> with the community.\\n\\nTrue. It seemed pretty obvious to me.\\n\\n> October, 2014:� EDB and NTT started working together in the community\\n> to start improving FDWs as a basis for an FDW-based sharding solution.\\n> Many of the 9.5 FDW improvements that also benefit sharding were developed\\n> by a combined EDB/NTT team.� The features improved FDWs independent of\\n> sharding, so they didn't need community buy-in on sharding to get them\\n> accepted.\\n> \\n> June, 2015:� I attended the PGCon sharding unconference session and\\n> there was a huge discussion about where we should go with sharding.\\n> I think the big take-away was that most people liked the FDW approach,\\n> but had business/customer reasons for wanting to work on XC or XL because\\n> those would be production-ready faster.\\n> \\n> \\n> Cough, cough. You must surely be joking that \\\"most people liked the FDW\\n> approach\\\"? How did we measure the acceptance of this approach?�\\n\\nWell, I didn't have my audience-meter with me at the time. ;-)\\n\\nThe discussion was mostly in the hallway after the unconference session,\\n\\\"Future of PostgreSQL shared-nothing cluster\\\" by Konstantin Knizhnik,\\nAlexander Korotkov, and Oleg Bartunov. Again, when I explained the\\nability to use FDWs to get sharding into Postgres with minimal\\nadditional code, no one said the idea was crazy, which I took as a big\\nthumbs-up! When I asked why to continue with XC/XL, I was told those\\nwere more mature and more customer-ready, which is true. I will not\\nquote people from the from the hallway discussion for privacy reasons.\\n\\n> What actually is the FDW approach? Since its not been written down anywhere, or\\n> even explained verbally, how can anyone actually agree to it?\\n\\nWell, my sharding talk just has the outlines of an approach. I think\\nthere are five broad segments:\\n\\n* FDW push-down of joins, sorts, aggregates\\n* ability to send FDW requests in parallel\\n* transaction/snapshot manager to allow ACID transctions on shards\\n* simpler user partitioning API\\n* infrastructure to manage shards, including replicated tables used for joins\\n\\n> July, 2015:� Oleg Bartunov and his new company Postgres Professional (PP)\\n> started to think about joining the FDW approach, rather than working on\\n> XL, as they had stated at PGCon in June.� A joint NTT/EDB/PP phone-in\\n> meeting is scheduled for September 1.\\n>\\n> August, 2015:� While speaking at SFPUG, Citus Data approached me about\\n> joining the FDW sharding team.� They have been invited to the September\\n> 1 meeting, as have the XC and XL people.\\n> \\n> \\n> 2ndQuadrant is working in this area, specifically bringing XL 9.5 forwards.\\n\\nYes, I saw the blog post about that:\\n\\n\\thttp://blog.2ndquadrant.com/working-towards-postgres-xl-9-5/\\n\\n> Please can invites be posted to myself, Pavan Deolasee and Petr Jelinek also?\\n> I'll pass on to others also.\\n\\nOK, I will send you a separate email and you can then supply their email\\naddresses.\\n\\n> Koichi Suzuki is arranging a meeting in Hong Long for XC/XL discussions.\\n> Presumably EDB is invited also? If Koichi is a leading organizer of this, why\\n> are there two meetings?\\n\\nI certainly have heard nothing about it, except third-hand people\\ntelling me a meeting is happening. I assumed those meetings where\\nXC/XL-specific.\\n\\n> that the XC approach is the only reasonable�way to do it,\\n> and that FDWs are the cleanest way to get it into community\\n> Postgres.\\n> \\n> Those two things aren't at all obvious to me.\\n>\\n> Please don't presume my opposition. If the technical information were made\\n> public, I might understand and agree with \\\"the FDW approach\\\", perhaps others\\n> also.\\n\\nWell, the beauty of my approach is that we didn't need any technical\\ndirection or buy-in on sharding from the community to improve FDWs. I\\nthink now is the right time to try to get that buy-in, or adjust our\\napproach.\\n\\nThere isn't really much more to my _analysis_ than I presented. There\\nis certainly a lot more work to do to even decide this is the right\\napproach. Some of the groups already involved have more experience in\\ntrying this, e.g. Citus Data.\\n\\n> 2ndQuadrant is certainly happy to become involved in any team aiming to\\n> add features to Postgres core, as long as that makes sense. There may be areas\\n> we can all agree upon even if the full architecture remains in doubt.\\n\\nRight.\\n\\n> Before the community commits to a long term venture together we should see the\\n> plan. Like all IT projects, expensive failure is possible and the lack of a\\n> design is a huge flashing red warning light for me at present. If that requires\\n> a meeting of all Developers, why are the meetings for this specifically not\\n> happening at the agreed Developer meetings?\\n\\nWell, what meetings should it be at? I don't think there was clear\\nenough direction for the June 2015 PGCon meeting. Is there an\\nunconference in Vienna? One thing I saw at the last PGCon is that this\\nis a big topic, so I think having a dedicated room and 3-hour slot for\\nit is nice.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 30 Aug 2015 18:29:43 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Sun, Aug 30, 2015 at 10:36:23PM +0300, Oleg Bartunov wrote:\\n> Honestly, I still don't know which approach is better, we already played with\\n> XL (ported to 9.4)� and identified some very strong issues with inconsistency,\\n> which scared us, especially taking into account how easy we found them. XC\\n> people have fixed them, but I'm not sure if they were fundamental and if we\\n> could construct more sophisticated tests and find more issues in XC/XL. We also\\n> a bit disappointed by Huawei position about CSN patch, we hoped to use for� our\\n> XTM.� FDW approach has been actively criticized by pg_shard people and that's\\n> also made me a bit suspicious.�\\n\\nYep, that has me concerned too. The pg_shard people will be on the\\nSeptember 1 call and are working on a Google document to explain their\\nconcerns about FDWs for sharding.\\n\\n> It looks like� we are doomed to continue\\n> several development forks, so we decided to work on very important common\\n> project, XTM, which we hoped could be accepted by all parties and eventually\\n> committed to 9.6.� Now I see we were right, unfortunately.��\\n\\nYes, the ability to add independent parts that can eventually be used\\nfor sharding is a strong indication that doing this incrementally is a\\ngood approach.\\n\\n> Again, could we organize meeting somewhere in September ?� US is not good for\\n> us, but other places should be ok. I want to have an agreement� at least on\\n> XTM. We still are testing various approaches, though. We could present results\\n> of our experiments and are open to discussion. It's not easy project, but it's\\n> something we could do for 9.6.\\n\\nGood. XTM is a must-have for several use-cases, including sharding.\\n\\n> I'm very glad Bruce started this discussion in -hackers, since it's silly to me\\n> to participate in both threads :)� Let's meet in September !\\n\\nIn summary, I think we need to start working on built-in sharding, and\\nFDWs are the only way I can see to do it with minimal code changes,\\nwhich I think might be a community requirement. It might not work, but\\nright now, it is the only possible approach I can see.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 30 Aug 2015 19:04:16 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 31, 2015 at 7:29 AM, Bruce Momjian <bruce@momjian.us> wrote:\\n\\n> On Sun, Aug 30, 2015 at 03:31:10PM +0100, Simon Riggs wrote:\\n> > I realized that we would never get community acceptance to dump the\\n> XC\\n> > (or XL) code needed for sharding into community Postgres\\n> >\\n> >\\n> > How or why did you realize that? There has never been any such\\n> discussion,\\n> > AFAIK. Surely it can be possible to move required subsystems across?\\n>\\n> Well, I have had many such discussions with XC/XL folks, and that was my\\n> opinion. I have seen almost no public discussion about this because the\\n> idea had almost no chance of success. If it was possible, someone would\\n> have already suggested it on this list.\\n>\\n\\nOr perhaps people invested in this area had other obligations or lacked\\nmotivation and/or time to work to push up for things in core. That's not\\npossible to know, and what is done is done.\\n\\n\\n> > July, 2015: Oleg Bartunov and his new company Postgres Professional\\n> (PP)\\n> > started to think about joining the FDW approach, rather than working\\n> on\\n> > XL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\\n> > meeting is scheduled for September 1.\\n> >\\n> > August, 2015: While speaking at SFPUG, Citus Data approached me\\n> about\\n> > joining the FDW sharding team. They have been invited to the\\n> September\\n> > 1 meeting, as have the XC and XL people.\\n> >\\n> >\\n> > 2ndQuadrant is working in this area, specifically bringing XL 9.5\\n> forwards.\\n>\\n> Yes, I saw the blog post about that:\\n>\\n> http://blog.2ndquadrant.com/working-towards-postgres-xl-9-5/\\n>\\n> > Please can invites be posted to myself, Pavan Deolasee and Petr Jelinek\\n> also?\\n> > I'll pass on to others also.\\n>\\n> OK, I will send you a separate email and you can then supply their email\\n> addresses.\\n>\\n\\nFWIW, I would be interested in that as well. I worked in this area of\\nthings for a couple of years as well FWIW.\\n\\n\\n> > Koichi Suzuki is arranging a meeting in Hong Long for XC/XL discussions.\\n> > Presumably EDB is invited also? If Koichi is a leading organizer of\\n> this, why\\n> > are there two meetings?\\n>\\n> I certainly have heard nothing about it, except third-hand people\\n> telling me a meeting is happening. I assumed those meetings where\\n> XC/XL-specific.\\n>\\n\\nYep, that's my understanding as well and AFAIK as I know things have been\\ncarried this way until now, aka XC/XL and Postgres core are aimed to live\\nas separate communities.\\n-- \\nMichael\\n\\nOn Mon, Aug 31, 2015 at 7:29 AM, Bruce Momjian <bruce@momjian.us> wrote:On Sun, Aug 30, 2015 at 03:31:10PM +0100, Simon Riggs wrote:\\n> I realized that we would never get community acceptance to dump the XC\\n> (or XL) code needed for sharding into community Postgres\\n>\\n>\\n> How or why did you realize that? There has never been any such discussion,\\n> AFAIK. Surely it can be possible to move required subsystems across?\\n\\nWell, I have had many such discussions with XC/XL folks, and that was my\\nopinion. I have seen almost no public discussion about this because the\\nidea had almost no chance of success. If it was possible, someone would\\nhave already suggested it on this list.Or perhaps people invested in this area had other obligations or lacked motivation and/or time to work to push up for things in core. That's not possible to know, and what is done is done. \\n> July, 2015: Oleg Bartunov and his new company Postgres Professional (PP)\\n> started to think about joining the FDW approach, rather than working on\\n> XL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\\n> meeting is scheduled for September 1.\\n>\\n> August, 2015: While speaking at SFPUG, Citus Data approached me about\\n> joining the FDW sharding team. They have been invited to the September\\n> 1 meeting, as have the XC and XL people.\\n>\\n>\\n> 2ndQuadrant is working in this area, specifically bringing XL 9.5 forwards.\\n\\nYes, I saw the blog post about that:\\n\\n http://blog.2ndquadrant.com/working-towards-postgres-xl-9-5/\\n\\n> Please can invites be posted to myself, Pavan Deolasee and Petr Jelinek also?\\n> I'll pass on to others also.\\n\\nOK, I will send you a separate email and you can then supply their email\\naddresses.FWIW, I would be interested in that as well. I worked in this area of things for a couple of years as well FWIW. \\n> Koichi Suzuki is arranging a meeting in Hong Long for XC/XL discussions.\\n> Presumably EDB is invited also? If Koichi is a leading organizer of this, why\\n> are there two meetings?\\n\\nI certainly have heard nothing about it, except third-hand people\\ntelling me a meeting is happening. I assumed those meetings where\\nXC/XL-specific.Yep, that's my understanding as well and AFAIK as I know things have been carried this way until now, aka XC/XL and Postgres core are aimed to live as separate communities.-- Michael\",\n \"msg_date\": \"Mon, 31 Aug 2015 09:53:57 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 31, 2015 at 09:53:57AM +0900, Michael Paquier wrote:\\n> Well, I have had many such discussions with XC/XL folks, and that was my\\n> opinion.� I have seen almost no public discussion about this because the\\n> idea had almost no chance of success.� If it was possible, someone would\\n> have already suggested it on this list.\\n> \\n> \\n> Or perhaps people invested in this area had other obligations or lacked\\n> motivation and/or time to work to push up for things in core. That's not\\n> possible to know, and what is done is done.\\n\\nWell, I have talked to everyone privately about this, and concluded that\\nwhile horizontal scalability/sharding is useful, it is unlikely that the\\ncode volume of something like XC or XL would be accepted into the\\ncommunity, and frankly, now that we have FDWs, it is hard to imagine why\\nwe would _not_ go in the FDW direction. \\n\\nOf course, people have concerns, and FDWs might need to be improved, but\\nit is something worth researching. We might find out FDWs can't be used\\nat all, and that we have to either add much more code to Postgres to do\\nsharding, do something like pg_shard, or not implement built-in sharding\\nat all, but at least it is time to research this.\\n\\n> OK, I will send you a separate email and you can then supply their email\\n> addresses.\\n> \\n> \\n> FWIW, I would be interested in that as well. I worked in this area of things\\n> for a couple of years as well FWIW.\\n\\nOK, I will send you an email.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 30 Aug 2015 22:08:06 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Sun, Aug 30, 2015 at 10:08:06PM -0400, Bruce Momjian wrote:\\n> On Mon, Aug 31, 2015 at 09:53:57AM +0900, Michael Paquier wrote:\\n> > Well, I have had many such discussions with XC/XL folks, and that was my\\n> > opinion.� I have seen almost no public discussion about this because the\\n> > idea had almost no chance of success.� If it was possible, someone would\\n> > have already suggested it on this list.\\n> > \\n> > \\n> > Or perhaps people invested in this area had other obligations or lacked\\n> > motivation and/or time to work to push up for things in core. That's not\\n> > possible to know, and what is done is done.\\n> \\n> Well, I have talked to everyone privately about this, and concluded that\\n> while horizontal scalability/sharding is useful, it is unlikely that the\\n> code volume of something like XC or XL would be accepted into the\\n> community, and frankly, now that we have FDWs, it is hard to imagine why\\n> we would _not_ go in the FDW direction. \\n\\nActually, there was hope that XC or XL would get popular enough that it\\nwould justify adding their code into community Postgres, but that never\\nhappened.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 30 Aug 2015 22:48:31 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 31, 2015 at 11:08 AM, Bruce Momjian <bruce@momjian.us> wrote:\\n>\\n> On Mon, Aug 31, 2015 at 09:53:57AM +0900, Michael Paquier wrote:\\n> > Well, I have had many such discussions with XC/XL folks, and that was my\\n> > opinion. I have seen almost no public discussion about this because the\\n> > idea had almost no chance of success. If it was possible, someone would\\n> > have already suggested it on this list.\\n> >\\n> >\\n> > Or perhaps people invested in this area had other obligations or lacked\\n> > motivation and/or time to work to push up for things in core. That's not\\n> > possible to know, and what is done is done.\\n>\\n> Well, I have talked to everyone privately about this, and concluded that\\n> while horizontal scalability/sharding is useful, it is unlikely that the\\n> code volume of something like XC or XL would be accepted into the\\n> community, and frankly, now that we have FDWs, it is hard to imagine why\\n> we would _not_ go in the FDW direction.\\n\\nIf I recall correctly in terms of numbers, that's indeed 40k of code,\\nthe main areas of XC code being the GTM, the planner changes for\\nexpression and join push down, and the connection pooler for parallel\\nquery execution.\\n\\nISTM that FDW is a portion of the puzzle, there are other pieces that\\ncould be used toward an in-core integration, like the parallel stuff\\nAmit Kapila is working on to allow remote query execution in parallel\\nof local scans. Also, XC/XL were performing well on OLTP thanks to the\\nconnection pooler: this should indeed be part of the FDW portion\\nmanaging the foreign scans. This may sound like a minor issue compared\\nto the others, but already established connections help a lot when\\nscaling out with foreign servers.\\n\\n> Of course, people have concerns, and FDWs might need to be improved, but\\n> it is something worth researching. We might find out FDWs can't be used\\n> at all, and that we have to either add much more code to Postgres to do\\n> sharding, do something like pg_shard, or not implement built-in sharding\\n> at all, but at least it is time to research this.\\n\\nI am really looking forward to hearing the arguments of the authors of\\npg_shard on the matter.\\n\\n> > OK, I will send you a separate email and you can then supply their email\\n> > addresses.\\n> >\\n> >\\n> > FWIW, I would be interested in that as well. I worked in this area of things\\n> > for a couple of years as well FWIW.\\n>\\n> OK, I will send you an email.\\n\\nThanks.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 31 Aug 2015 12:03:37 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 31, 2015 at 11:48 AM, Bruce Momjian <bruce@momjian.us> wrote:\\n> On Sun, Aug 30, 2015 at 10:08:06PM -0400, Bruce Momjian wrote:\\n>> On Mon, Aug 31, 2015 at 09:53:57AM +0900, Michael Paquier wrote:\\n>> > Well, I have had many such discussions with XC/XL folks, and that was my\\n>> > opinion. I have seen almost no public discussion about this because the\\n>> > idea had almost no chance of success. If it was possible, someone would\\n>> > have already suggested it on this list.\\n>> >\\n>> >\\n>> > Or perhaps people invested in this area had other obligations or lacked\\n>> > motivation and/or time to work to push up for things in core. That's not\\n>> > possible to know, and what is done is done.\\n>>\\n>> Well, I have talked to everyone privately about this, and concluded that\\n>> while horizontal scalability/sharding is useful, it is unlikely that the\\n>> code volume of something like XC or XL would be accepted into the\\n>> community, and frankly, now that we have FDWs, it is hard to imagine why\\n>> we would _not_ go in the FDW direction.\\n>\\n> Actually, there was hope that XC or XL would get popular enough that it\\n> would justify adding their code into community Postgres, but that never\\n> happened.\\n\\nForks are aimed to die without proper maintenance resources. Still,\\nfor XC/XL, what does not help is the complication of the architecture\\nand SPOF management, particularly thinking with the GTM that was\\nsomething completely new and not well understood (there is a GTM\\nstandby but this model is weak IMO and does not scale similarly to\\nwhat you get with standbys, and impacts the overall performance of the\\ncluster).\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 31 Aug 2015 12:06:53 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Sun, Aug 30, 2015 at 7:47 AM, Bruce Momjian <bruce@momjian.us> wrote:\\n>\\n> I have recently increased my public statements about the idea of adding\\n> horizontal scaling/sharding to Postgres. I wanted to share with hackers\\n> a timeline of how we got here, and where I think we are going in the\\n> short term:\\n>\\n> 2012-2013: As part of writing my scaling talk\\n> (http://momjian.us/main/presentations/overview.html#scaling), studying\\n> Oracle RAC, and talking to users, it became clear that an XC-like\\n> architecture (sharding) was the only architecture that was going to allow\\n> for write scaling.\\n>\\n\\nI think sharding like architecture is quite useful for certain kind of\\nworkloads\\nwhere users can manage to arrange queries and data layout in an optimized\\nway which I hope users might agree to change if required. One thing to\\nconsider here is what kind of scaling are we expecting in such a system and\\nis it sufficient considering we will keep focussed on this architecture for\\nhorizontal scalability?\\nGenerally speaking, the scaling in such systems is limited by the number of\\nprofitable partitions user can create based on data and then cross-partition\\ntransactions sucks the performance/scalability in such systems. I\\nunderstand that there is definitely a benefit in proceeding with sharding\\nlike\\narchitecture as there are already some PostgreSQL based forks which uses\\nsuch architecture, so if we follow same way, we can save some effort rather\\nthan inventing or following some other architecture, however there is no\\nharm\\nis discussing pros and cons of some other architectures like Oracle RAC,\\nGoogle F1 or others.\\n\\n\\nWith Regards,\\nAmit Kapila.\\nEnterpriseDB: http://www.enterprisedb.com\\n\\nOn Sun, Aug 30, 2015 at 7:47 AM, Bruce Momjian <bruce@momjian.us> wrote:>> I have recently increased my public statements about the idea of adding> horizontal scaling/sharding to Postgres. I wanted to share with hackers> a timeline of how we got here, and where I think we are going in the> short term:>> 2012-2013: As part of writing my scaling talk> (http://momjian.us/main/presentations/overview.html#scaling), studying> Oracle RAC, and talking to users, it became clear that an XC-like> architecture (sharding) was the only architecture that was going to allow> for write scaling.>I think sharding like architecture is quite useful for certain kind of workloadswhere users can manage to arrange queries and data layout in an optimizedway which I hope users might agree to change if required. One thing toconsider here is what kind of scaling are we expecting in such a system andis it sufficient considering we will keep focussed on this architecture forhorizontal scalability?Generally speaking, the scaling in such systems is limited by the number ofprofitable partitions user can create based on data and then cross-partitiontransactions sucks the performance/scalability in such systems. Iunderstand that there is definitely a benefit in proceeding with sharding likearchitecture as there are already some PostgreSQL based forks which usessuch architecture, so if we follow same way, we can save some effort ratherthan inventing or following some other architecture, however there is no harmis discussing pros and cons of some other architectures like Oracle RAC,Google F1 or others.With Regards,Amit Kapila.EnterpriseDB: http://www.enterprisedb.com\",\n \"msg_date\": \"Mon, 31 Aug 2015 10:18:25 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \">\\n>\\n> At PGCon we agreed to have such meeting in Vienna at least. But I think we\\n> should be prepared and try to clean all our issues before. It looks like we\\n> already out of time,but probably we could meet in Hong Kong ?\\n>\\n> Honestly, I still don't know which approach is better, we already played\\n> with XL (ported to 9.4) and identified some very strong issues with\\n> inconsistency, which scared us, especially taking into account how easy we\\n> found them. XC people have fixed them, but I'm not sure if they were\\n> fundamental and if we could construct more sophisticated tests and find\\n> more issues in XC/XL. We also a bit disappointed by Huawei position about\\n> CSN patch, we hoped to use for our XTM. FDW approach has been actively\\n> criticized by pg_shard people and that's also made me a bit suspicious. It\\n> looks like we are doomed to continue several development forks, so we\\n> decided to work on very important common project, XTM, which we hoped could\\n> be accepted by all parties and eventually committed to 9.6. Now I see we\\n> were right, unfortunately.\\n>\\n\\nDistributed transaction manager should support at least three things\\n1. Atomic commit\\n2. Atomic visibility\\n3. Consistent snapshots (e.g. required for repeatable reads and higher\\nisolation levels).\\n\\nI have submitted patch for implementing first for FDWs. The patch adds\\ninfrastructure to be used by all FDWs including postgres_fdw. It also adds\\npostgres_fdw code to use this infrastructure. The same can be used to\\nachieve atomic commit in postgres_fdw based sharding. Please see if XTM can\\nbenefit from it. If there are things that are required by XTM, please post\\nthe requirements on that thread and I will work on those. You can find the\\nlatest patch at\\nhttp://www.postgresql.org/message-id/CAFjFpRfANWL53+x2HdM9TCNe5pup=oPkQSSJ-KGfr-d2efj+CQ@mail.gmail.com\\n\\n\\n>\\n> Again, could we organize meeting somewhere in September ? US is not good\\n> for us, but other places should be ok. I want to have an agreement at\\n> least on XTM. We still are testing various approaches, though. We could\\n> present results of our experiments and are open to discussion. It's not\\n> easy project, but it's something we could do for 9.6.\\n>\\n> I'm very glad Bruce started this discussion in -hackers, since it's silly\\n> to me to participate in both threads :) Let's meet in September !\\n>\\n>\\n>\\n>> --\\n>> Simon Riggs http://www.2ndQuadrant.com/\\n>> <http://www.2ndquadrant.com/>\\n>> PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n>>\\n>\\n>\\n\\n\\n-- \\nBest Wishes,\\nAshutosh Bapat\\nEnterpriseDB Corporation\\nThe Postgres Database Company\\n\\nAt PGCon we agreed to have such meeting in Vienna at least. But I think we should be prepared and try to clean all our issues before. It looks like we already out of time,but probably we could meet in Hong Kong ? Honestly, I still don't know which approach is better, we already played with XL (ported to 9.4) and identified some very strong issues with inconsistency, which scared us, especially taking into account how easy we found them. XC people have fixed them, but I'm not sure if they were fundamental and if we could construct more sophisticated tests and find more issues in XC/XL. We also a bit disappointed by Huawei position about CSN patch, we hoped to use for our XTM. FDW approach has been actively criticized by pg_shard people and that's also made me a bit suspicious. It looks like we are doomed to continue several development forks, so we decided to work on very important common project, XTM, which we hoped could be accepted by all parties and eventually committed to 9.6. Now I see we were right, unfortunately.Distributed transaction manager should support at least three things1. Atomic commit2. Atomic visibility3. Consistent snapshots (e.g. required for repeatable reads and higher isolation levels).I have submitted patch for implementing first for FDWs. The patch adds infrastructure to be used by all FDWs including postgres_fdw. It also adds postgres_fdw code to use this infrastructure. The same can be used to achieve atomic commit in postgres_fdw based sharding. Please see if XTM can benefit from it. If there are things that are required by XTM, please post the requirements on that thread and I will work on those. You can find the latest patch at http://www.postgresql.org/message-id/CAFjFpRfANWL53+x2HdM9TCNe5pup=oPkQSSJ-KGfr-d2efj+CQ@mail.gmail.com Again, could we organize meeting somewhere in September ? US is not good for us, but other places should be ok. I want to have an agreement at least on XTM. We still are testing various approaches, though. We could present results of our experiments and are open to discussion. It's not easy project, but it's something we could do for 9.6.I'm very glad Bruce started this discussion in -hackers, since it's silly to me to participate in both threads :) Let's meet in September ! -- Simon Riggs http://www.2ndQuadrant.com/PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- Best Wishes,Ashutosh BapatEnterpriseDB CorporationThe Postgres Database Company\",\n \"msg_date\": \"Mon, 31 Aug 2015 10:52:28 +0530\",\n \"msg_from\": \"Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 31, 2015 at 5:48 AM, Bruce Momjian <bruce@momjian.us> wrote:\\n\\n> On Sun, Aug 30, 2015 at 10:08:06PM -0400, Bruce Momjian wrote:\\n> > On Mon, Aug 31, 2015 at 09:53:57AM +0900, Michael Paquier wrote:\\n> > > Well, I have had many such discussions with XC/XL folks, and that\\n> was my\\n> > > opinion. I have seen almost no public discussion about this\\n> because the\\n> > > idea had almost no chance of success. If it was possible, someone\\n> would\\n> > > have already suggested it on this list.\\n> > >\\n> > >\\n> > > Or perhaps people invested in this area had other obligations or lacked\\n> > > motivation and/or time to work to push up for things in core. That's\\n> not\\n> > > possible to know, and what is done is done.\\n> >\\n> > Well, I have talked to everyone privately about this, and concluded that\\n> > while horizontal scalability/sharding is useful, it is unlikely that the\\n> > code volume of something like XC or XL would be accepted into the\\n> > community, and frankly, now that we have FDWs, it is hard to imagine why\\n> > we would _not_ go in the FDW direction.\\n>\\n> Actually, there was hope that XC or XL would get popular enough that it\\n> would justify adding their code into community Postgres, but that never\\n> happened.\\n>\\n\\nAFAIK, XC/XL has already some customers and that is an additional pressure\\non their development team, which is now called X2. I don't exactly know how\\ninternal Huawei's MPPDB is connected to XC/XL.\\n\\nWe need community test suite for cluster and our company is working on\\nthis. It's non-trivial work, but community will never accepts any cluster\\nsolution without thorough testing of functionality and performance. Our\\nXC/XL experience was not good.\\n\\n\\n\\n>\\n> --\\n> Bruce Momjian <bruce@momjian.us> http://momjian.us\\n> EnterpriseDB http://enterprisedb.com\\n>\\n> + Everyone has their own god. +\\n>\\n>\\n> --\\n> Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\n> To make changes to your subscription:\\n> http://www.postgresql.org/mailpref/pgsql-hackers\\n>\\n\\nOn Mon, Aug 31, 2015 at 5:48 AM, Bruce Momjian <bruce@momjian.us> wrote:On Sun, Aug 30, 2015 at 10:08:06PM -0400, Bruce Momjian wrote:\\n> On Mon, Aug 31, 2015 at 09:53:57AM +0900, Michael Paquier wrote:\\n> > Well, I have had many such discussions with XC/XL folks, and that was my\\n> > opinion. I have seen almost no public discussion about this because the\\n> > idea had almost no chance of success. If it was possible, someone would\\n> > have already suggested it on this list.\\n> >\\n> >\\n> > Or perhaps people invested in this area had other obligations or lacked\\n> > motivation and/or time to work to push up for things in core. That's not\\n> > possible to know, and what is done is done.\\n>\\n> Well, I have talked to everyone privately about this, and concluded that\\n> while horizontal scalability/sharding is useful, it is unlikely that the\\n> code volume of something like XC or XL would be accepted into the\\n> community, and frankly, now that we have FDWs, it is hard to imagine why\\n> we would _not_ go in the FDW direction.\\n\\nActually, there was hope that XC or XL would get popular enough that it\\nwould justify adding their code into community Postgres, but that never\\nhappened.AFAIK, XC/XL has already some customers and that is an additional pressure on their development team, which is now called X2. I don't exactly know how internal Huawei's MPPDB is connected to XC/XL. We need community test suite for cluster and our company is working on this. It's non-trivial work, but community will never accepts any cluster solution without thorough testing of functionality and performance. Our XC/XL experience was not good. \\n\\n--\\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n--\\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\",\n \"msg_date\": \"Mon, 31 Aug 2015 12:12:02 +0300\",\n \"msg_from\": \"Oleg Bartunov <obartunov@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \">\\n>\\n> We also a bit disappointed by Huawei position about CSN patch, we hoped\\n> to use for our XTM.\\n>\\n\\nDisappointed in what way? Moving to some sort of CSN approach seems to open\\nthings up for different future ideas. In the short term, it would mean\\nreplacing potentially large snapshots and longer visibility checks. In the\\nlong term, perhaps CSN could help simplify the design of multi-master\\nreplication schemes.\\n\\n\\n> FDW approach has been actively criticized by pg_shard people and that's\\n> also made me a bit suspicious. It looks like we are doomed to continue\\n> several development forks, so we decided to work on very important common\\n> project, XTM, which we hoped could be accepted by all parties and\\n> eventually committed to 9.6. Now I see we were right, unfortunately.\\n>\\n>\\nI think the original XC project probably would have taken the FDW approach\\nas a basis if it had existed, with focus on push-down optimizations.\\n\\nI assume that future work around PG sharding probably would be more likely\\nto be accepted with the FDW approach. One could perhaps work on pushing\\ndown joins, aggregates and order by, then look at any optimizations gained\\nif code is moved outside of FDW. It would make sense if some kind of\\ngeneric optimization for foreign tables for SQL-based sources could be\\nleveraged across all databases, rather than having to re-implement for each\\nFDW.\\n\\nThere are different approaches and related features that may need to be\\nimproved.\\n\\nDo we want multiple copies of shards, like the pg_shard approach? Or keep\\nthings simpler and leave it up to the DBA to add standbys?\\n\\nDo we want to leverage table inheritance? If so, we may want to spend time\\nimproving performance for when the number of shards becomes large with what\\ncurrently exists. If using table inheritance, we could add the ability to\\nspecify what node (er, foreign server) the subtable lives on. We could\\ncreate top level sharding expressions that allow these to be implicitly\\ncreated.\\n\\nShould we allow arbitrary expressions for shards, not just range, list and\\nhash?\\n\\nMaybe the most community-acceptable approach would look something like\\n\\n- Use FDWs, and continue to optimize push-down operations, also for\\nnon-PostgreSQL databases.\\n\\n- Use table inheritance for defining the shards. Ideally allow for\\nspecifying that some shards may be replicated to other foreign servers (and\\nitself) (for pushing down joins with lookup/static tables; at this point it\\nshould be decent for star schema based data warehouses).\\n\\n- XTM/GTM hooks. Preferably we move to CSN for snapshots in core PostgreSQL\\nthough.\\n\\nLonger term, efficient internode joins would require a lot more work.\\n\\nThe devil is in the details. There are things that have to be addressed,\\nfor example, if using global XIDs via GTM, not every transaction is on\\nevery node, so we need to make sure that new clog pages get added\\nproperly. There is also the potential to require a lot more code to be\\nadded, like for cursor handling and stored functions. Perhaps some\\nlimitations when using shards to foreign servers are acceptable if it is\\ndesired to minimize code changes. XC and XL code help.\\n\\nRegards,\\n\\nMason\\n\\n We also a bit disappointed by Huawei position about CSN patch, we hoped to use for our XTM. Disappointed in what way? Moving to some sort of CSN approach seems to open things up for different future ideas. In the short term, it would mean replacing potentially large snapshots and longer visibility checks. In the long term, perhaps CSN could help simplify the design of multi-master replication schemes. FDW approach has been actively criticized by pg_shard people and that's also made me a bit suspicious. It looks like we are doomed to continue several development forks, so we decided to work on very important common project, XTM, which we hoped could be accepted by all parties and eventually committed to 9.6. Now I see we were right, unfortunately. I think the original XC project probably would have taken the FDW approach as a basis if it had existed, with focus on push-down optimizations. I assume that future work around PG sharding probably would be more likely to be accepted with the FDW approach. One could perhaps work on pushing down joins, aggregates and order by, then look at any optimizations gained if code is moved outside of FDW. It would make sense if some kind of generic optimization for foreign tables for SQL-based sources could be leveraged across all databases, rather than having to re-implement for each FDW.There are different approaches and related features that may need to be improved.Do we want multiple copies of shards, like the pg_shard approach? Or keep things simpler and leave it up to the DBA to add standbys? Do we want to leverage table inheritance? If so, we may want to spend time improving performance for when the number of shards becomes large with what currently exists. If using table inheritance, we could add the ability to specify what node (er, foreign server) the subtable lives on. We could create top level sharding expressions that allow these to be implicitly created.Should we allow arbitrary expressions for shards, not just range, list and hash?Maybe the most community-acceptable approach would look something like- Use FDWs, and continue to optimize push-down operations, also for non-PostgreSQL databases.- Use table inheritance for defining the shards. Ideally allow for specifying that some shards may be replicated to other foreign servers (and itself) (for pushing down joins with lookup/static tables; at this point it should be decent for star schema based data warehouses). - XTM/GTM hooks. Preferably we move to CSN for snapshots in core PostgreSQL though.Longer term, efficient internode joins would require a lot more work.The devil is in the details. There are things that have to be addressed, for example, if using global XIDs via GTM, not every transaction is on every node, so we need to make sure that new clog pages get added properly. There is also the potential to require a lot more code to be added, like for cursor handling and stored functions. Perhaps some limitations when using shards to foreign servers are acceptable if it is desired to minimize code changes. XC and XL code help.Regards,Mason\",\n \"msg_date\": \"Mon, 31 Aug 2015 14:48:31 -0400\",\n \"msg_from\": \"Mason S <masonlists@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 31, 2015 at 02:48:31PM -0400, Mason S wrote:\\n> I assume that future work around PG sharding probably would be more likely to\\n> be accepted with the FDW approach. One could perhaps work on pushing down\\n> joins, aggregates and order by, then look at any optimizations gained if code\\n> is moved outside of FDW.� It would make sense if some kind of generic\\n> optimization for foreign tables for SQL-based sources could be leveraged across\\n> all databases, rather than having to re-implement for each FDW.\\n> \\n> There are different approaches and related features that may need to be\\n> improved.\\n> \\n> Do we want multiple copies of shards, like the pg_shard approach? Or keep\\n> things simpler and leave it up to the DBA to add standbys?�\\n\\nI agree with all of the above.\\n\\n> Do we want to leverage table inheritance? If so, we may want to spend time\\n> improving performance for when the number of shards becomes large with what\\n> currently exists. If using table inheritance, we could add the ability to\\n> specify what node (er, foreign server) the subtable lives on. We could create\\n> top level sharding expressions that allow these to be implicitly created.\\n> \\n> Should we allow arbitrary expressions for shards, not just range, list and\\n> hash?\\n> \\n> Maybe the most community-acceptable approach would look something like\\n\\nI think everyone agrees that our current partitioning setup is just too\\nverbose and error-prone for users, and needs a simpler interface, and\\none that can be better optimized internally. I assume FDW-based\\nsharding will benefit from that work as well.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 31 Aug 2015 14:59:47 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 31, 2015 at 9:48 PM, Mason S <masonlists@gmail.com> wrote:\\n\\n>\\n>> We also a bit disappointed by Huawei position about CSN patch, we hoped\\n>> to use for our XTM.\\n>>\\n>\\n> Disappointed in what way? Moving to some sort of CSN approach seems to\\n> open things up for different future ideas. In the short term, it would mean\\n> replacing potentially large snapshots and longer visibility checks. In the\\n> long term, perhaps CSN could help simplify the design of multi-master\\n> replication schemes.\\n>\\n\\nWe are disappointed because at PGCon talk Huawei announced publishing of\\ntheir CSN patch and further work in this direction together with community.\\nHowever, it's even not published yet despite all the promises. Nobody from\\nHuawei answers CSN thread in the hackers.\\nSo, I think we got nothing from Huawei except teasing and should rely only\\non ourselves. That is disappointing.\\n\\n------\\nAlexander Korotkov\\nPostgres Professional: http://www.postgrespro.com\\nThe Russian Postgres Company\\n\\nOn Mon, Aug 31, 2015 at 9:48 PM, Mason S <masonlists@gmail.com> wrote: We also a bit disappointed by Huawei position about CSN patch, we hoped to use for our XTM. Disappointed in what way? Moving to some sort of CSN approach seems to open things up for different future ideas. In the short term, it would mean replacing potentially large snapshots and longer visibility checks. In the long term, perhaps CSN could help simplify the design of multi-master replication schemes. We are disappointed because at PGCon talk Huawei announced publishing of their CSN patch and further work in this direction together with community. However, it's even not published yet despite all the promises. Nobody from Huawei answers CSN thread in the hackers.So, I think we got nothing from Huawei except teasing and should rely only on ourselves. That is disappointing.------Alexander KorotkovPostgres Professional: http://www.postgrespro.comThe Russian Postgres Company\",\n \"msg_date\": \"Mon, 31 Aug 2015 22:08:14 +0300\",\n \"msg_from\": \"Alexander Korotkov <a.korotkov@postgrespro.ru>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 31, 2015 at 2:12 AM, Oleg Bartunov <obartunov@gmail.com> wrote:\\n>\\n> AFAIK, XC/XL has already some customers and that is an additional pressure\\n> on their development team, which is now called X2. I don't exactly know how\\n> internal Huawei's MPPDB is connected to XC/XL.\\n>\\n\\nHuawei's MPPDB is based on PG-XC and tailored it more targeting OLAP scenarios.\\n\\nThe basic idea is that OLAP needs a shared nothing scale out\\narchitecture for read and write. It needs ok-TP-performance, a\\nrestricted set of functionality, and thus avoids some problems like\\nGTM being a central scaling bottleneck.\\n\\nI advocate to merge PostgreSQL core with scale-out features, if we are\\nready to face some long time functional discrepancies between the two\\ndeployments.\\n\\nRegards,\\nQingqing\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 31 Aug 2015 12:54:27 -0700\",\n \"msg_from\": \"Qingqing Zhou <zhouqq.postgres@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"All, Bruce:\\n\\nFirst, let me put out there that I think the horizontal scaling project\\nwhich has buy-in from the community and we're working on is infinitely\\nbetter than the one we're not working on or is an underresourced fork.\\nSo we're in agreement on that. However, I think there's a lot of room\\nfor discussion; I feel like the FDW approach was decided in exclusive\\nmeetings involving a very small number of people. The FDW approach\\n*may* be the right approach, but I'd like to see some rigorous\\nquestioning of that before it's final.\\n\\nParticularly, I'm concerned that we already have two projects in process\\naimed at horizontal scalability, and it seems like we could bring either\\n(or both) projects to production quality MUCH faster than we could make\\nan FDW-based solution work. These are:\\n\\n* pg_shard\\n* BDR\\n\\nIt seems worthwhile, just as a thought experiment, if we can get where\\nwe want using those, faster, or by combining those with new FDW features.\\n\\nIt's also important to recognize that there are three major use-cases\\nfor write-scalable clustering:\\n\\n* OLTP: small-medium cluster, absolute ACID consistency,\\n bottlnecked on small writes per second\\n* DW: small-large cluster, ACID optional,\\n bottlenecked on bulk reads/writes\\n* Web: medium to very large cluster, ACID optional,\\n bottlenecked on # of connections\\n\\nWe cannot possibly solve all of the above at once, but to the extent\\nthat we recognize all 3 use cases, we can build core features which can\\nbe adapted to all of them.\\n\\nI'm also going to pontificate that, for a future solution, we should not\\nfocus on write *IO*, but rather on CPU and RAM. The reason for this\\nthinking is that, with the latest improvements in hardware and 9.5\\nimprovements, it's increasingly rare for machines to be bottlenecked on\\nwrites to the transaction log (or the heap). This has some implications\\nfor system design. For example, solutions which require all connections\\nto go through a single master node do not scale sufficiently to be worth\\nbothering with.\\n\\nOn some other questions from Mason:\\n\\n> Do we want multiple copies of shards, like the pg_shard approach? Or\\n> keep things simpler and leave it up to the DBA to add standbys? \\n\\nWe want multiple copies of shards created by the sharding system itself.\\n Having a separate, and completely orthagonal, redundancy system to the\\nsharding system is overly burdensome on the DBA and makes low-data-loss\\nHA impossible.\\n\\n> Do we want to leverage table inheritance? If so, we may want to spend\\n> time improving performance for when the number of shards becomes large\\n> with what currently exists. If using table inheritance, we could add the\\n> ability to specify what node (er, foreign server) the subtable lives on.\\n> We could create top level sharding expressions that allow these to be\\n> implicitly created.\\n\\nIMHO, given that we're looking at replacing inheritance because of its\\nmany documented limitations, building sharding on top of inheritance\\nseems unwise. For example, many sharding systems are hash-based; how\\nwould an inheritance system transparently use hash keys?\\n\\n> Should we allow arbitrary expressions for shards, not just range, list\\n> and hash?\\n\\nThat seems like a 2.0 feature. It also doesn't seem necessary to\\nsupport it for the moderately skilled user; that is, requiring a special\\nC sharding function for this seems fine to me.\\n\\n-- \\nJosh Berkus\\nPostgreSQL Experts Inc.\\nhttp://pgexperts.com\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 31 Aug 2015 13:16:21 -0700\",\n \"msg_from\": \"Josh Berkus <josh@agliodbs.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 08/31/2015 01:16 PM, Josh Berkus wrote:\\n> All, Bruce:\\n>\\n\\n> I'm also going to pontificate that, for a future solution, we should not\\n> focus on write *IO*, but rather on CPU and RAM. The reason for this\\n> thinking is that, with the latest improvements in hardware and 9.5\\n> improvements, it's increasingly rare for machines to be bottlenecked on\\n> writes to the transaction log (or the heap). This has some implications\\n> for system design. For example, solutions which require all connections\\n> to go through a single master node do not scale sufficiently to be worth\\n> bothering with.\\n\\nWe see this already, under very high concurrency (lots of connections, \\nmany cores) we often see a significant drop in performance that is not \\nrelated to IO in any meaningful way.\\n\\nJD\\n\\n\\n-- \\nCommand Prompt, Inc. - http://www.commandprompt.com/ 503-667-4564\\nPostgreSQL Centered full stack support, consulting and development.\\nAnnouncing \\\"I'm offended\\\" is basically telling the world you can't\\ncontrol your own emotions, so everyone else should do it for you.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 31 Aug 2015 13:23:25 -0700\",\n \"msg_from\": \"\\\"Joshua D. Drake\\\" <jd@commandprompt.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 31, 2015 at 4:16 PM, Josh Berkus <josh@agliodbs.com> wrote:\\n> First, let me put out there that I think the horizontal scaling project\\n> which has buy-in from the community and we're working on is infinitely\\n> better than the one we're not working on or is an underresourced fork.\\n> So we're in agreement on that. However, I think there's a lot of room\\n> for discussion; I feel like the FDW approach was decided in exclusive\\n> meetings involving a very small number of people. The FDW approach\\n> *may* be the right approach, but I'd like to see some rigorous\\n> questioning of that before it's final.\\n\\nIt seems to me that sharding consists of (1) breaking your data set up\\ninto shards, (2) possibly replicating some of those shards onto\\nmultiple machines, and then (3) being able to access the remote data\\nfrom local queries. As far as (1) is concerned, we need declarative\\npartitioning, which is being worked on by Amit Langote. As far as (2)\\nis concerned, I hope and expect BDR, or technology derived therefrom,\\nto eventually fill that need. As far as (3) is concerned, why\\nwouldn't we use the foreign data wrapper interface, and specifically\\npostgres_fdw? That interface was designed for the explicit purpose of\\nallowing access to remote data sources, and a lot of work has been put\\ninto it, so it would be highly surprising if we decided to throw that\\naway and develop something completely new from the ground up.\\n\\nIt's true that postgres_fdw doesn't do everything we need yet. The\\nnew join pushdown hooks aren't used by postgres_fdw yet, and the API\\nitself has some bugs with EvalPlanQual handling. Aggregate pushdown\\nis waiting on upper planner path-ification. DML pushdown doesn't\\nexist yet, and the hooks that would enable pushdown of ORDER BY\\nclauses to the remote side aren't being used by postgres_fdw. But all\\nof these things have been worked on. Patches for many of them have\\nalready been posted. They have suffered from a certain amount of\\nneglect by senior hackers, and perhaps also from a shortage of time on\\nthe part of the authors. But an awful lot of the work that is needed\\nhere has already been done, if only we could get it committed.\\nAggregate pushdown is a notable exception, but abandoning the foreign\\ndata wrapper approach in favor of something else won't fix that.\\n\\nPostgres-XC developed a purpose-built system for talking to other\\nnodes instead of using the FDW interface, for the very good reason\\nthat the FDW interface did not yet exist at the time that Postgres-XC\\nwas created. But several people associated with the XC project have\\nsaid, including one on this thread, that if it had existed, they\\nprobably would have used it. And it's hard to see why you wouldn't:\\nwith XC's approach, the remote data source is presumed to be\\nPostgreSQL (or Postgres-XC/XL/X2/whatever); and you can only use the\\nfacility as part of a sharding solution. The FDW interface can talk\\nto anything, and it can be used for stuff other than sharding, like\\nmaking one remote table appear local because you just happen to want\\nthat for some reason. This makes the XC approach look rather brittle\\nby comparison. I don't blame the XC folks for taking the shortest\\npath between two points, but FDWs are better, and we ought to try to\\nleverage that.\\n\\n> Particularly, I'm concerned that we already have two projects in process\\n> aimed at horizontal scalability, and it seems like we could bring either\\n> (or both) projects to production quality MUCH faster than we could make\\n> an FDW-based solution work. These are:\\n>\\n> * pg_shard\\n> * BDR\\n>\\n> It seems worthwhile, just as a thought experiment, if we can get where\\n> we want using those, faster, or by combining those with new FDW features.\\n\\nI think it's abundantly clear that we need a logical replication\\nsolution as part of any horizontal scalability story. People will\\nwant to do things like have 10 machines with each piece of data on 3\\nof them, and there won't be any reasonable way of doing that without\\nlogical replication. I assume that BDR, or some technology derived\\nfrom it, will end up in core and solve that problem. I had actually\\nhoped we were going to get that in 9.5, but it didn't happen that way.\\nStill, I think that getting first single-master, and then eventually\\nmulti-master, logical replication in core is absolutely critical. And\\nnot just for sharding specifically: replicating your whole database to\\nseveral nodes and load-balancing your clients across them isn't\\nsharding, but it does give you read scalability and is a good fit for\\npeople with geographically dispersed data with good geographical\\nlocality. I think a lot of people will want that.\\n\\nI'm not quite sure yet how we can marry declarative partitioning and\\nbetter FDW-pushdown and logical replication into one seamless, easy to\\ndeploy solution that requires very low administrator effort. But I am\\nsure that each of those things, taken individually, is very useful,\\nand that being able to construct a solution from those building blocks\\nwould be a big improvement over what we have today. I can't imagine\\nthat trying to do one monolithic project that provides all of those\\nthings, but only if you combine them in the specific way that the\\ndesigner had in mind, is ever going to be successful. People _will_\\nwant access to each of those features in an unbundled fashion. And,\\ntrying to do them altogether leads to trying to solve too many\\nproblems at once. I think the history of Postgres-XC is a cautionary\\ntale there.\\n\\nI don't really understand how pg_shard fits into this equation. It\\nlooks to me like it does some interesting things but, for example, it\\ndoesn't support JOIN pushdown, and suggests that you use the\\nproprietary CitusDB engine if you need that. But I think JOIN\\npushdown is something we want to have in core, not something where we\\nwant to point people to proprietary alternatives. And it has some\\nrestrictions on INSERT statements - they have to contain only values\\nwhich are constants or which can be folded to constants. I'm just\\nguessing, but I bet that's probably due to some limitation which\\npg_shard, being out of core, has difficulty overcoming, but we can do\\nbetter in core. Basically I guess I expect much of what pg_shard does\\nto be subsumed as we improve FDWs, but maybe not all of it.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 31 Aug 2015 17:47:12 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"Hi Bruce,\\n\\nSumedh from Citus Data here.\\n\\n> August, 2015: While speaking at SFPUG, Citus Data approached me about joining\\nthe FDW sharding team. They have been invited to the September 1 meeting,\\nas have the XC and XL people.\\n\\nI'd like to add a clarification. We already tried the FDW APIs for pg_shard\\ntwo years ago and failed. We figured sharing our learnings could contribute\\nto the technical discussion and that's why we wanted to be in the call.\\n\\nOzgun summarized our technical learnings in this design document:\\nhttps://goo.gl/vJWF85\\n\\nIn the document, we focused on one of the four learnings we had with FDW\\nAPIs. For us, we switched to the hook API based approach, and things went\\nsmoothly from there.\\n\\nBest,\\nSumedh\\n\\nOn Sat, Aug 29, 2015 at 7:17 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n\\n> I have recently increased my public statements about the idea of adding\\n> horizontal scaling/sharding to Postgres. I wanted to share with hackers\\n> a timeline of how we got here, and where I think we are going in the\\n> short term:\\n>\\n> 2012-2013: As part of writing my scaling talk\\n> (http://momjian.us/main/presentations/overview.html#scaling), studying\\n> Oracle RAC, and talking to users, it became clear that an XC-like\\n> architecture (sharding) was the only architecture that was going to allow\\n> for write scaling.\\n>\\n> Users and conference attendees I talked to were increasingly concerned\\n> about the ability of Postgres to scale for high write volumes. They didn't\\n> necessarily need that scale now, but they needed to know they could get\\n> it if they wanted it, and wouldn't need to switch to a new database in\\n> the future. This is similar to wanting a car that can get you on a highway\\n> on-ramp fast --- even if you don't need it, you want to know it is there.\\n>\\n> 2014: I started to shop around the idea that we could use FDWs,\\n> parallelism, and a transaction/snapshot manager to get XC features\\n> as built-in to Postgres. (I don't remember where the original idea\\n> came from.) It was clear that having separate forks of the source code\\n> in XC and XL was never going to achieve critical mass --- there just\\n> aren't enough people who need high right scale right now, and the fork\\n> maintenance overhead is a huge burden.\\n>\\n> I realized that we would never get community acceptance to dump the XC\\n> (or XL) code needed for sharding into community Postgres, but with FDWs,\\n> we could add the features as _part_ of improving FDWs, which would benefit\\n> FDWs _and_ would be useful for sharding. (We already see some of those\\n> FDW features in 9.5.)\\n>\\n> October, 2014: EDB and NTT started working together in the community\\n> to start improving FDWs as a basis for an FDW-based sharding solution.\\n> Many of the 9.5 FDW improvements that also benefit sharding were developed\\n> by a combined EDB/NTT team. The features improved FDWs independent of\\n> sharding, so they didn't need community buy-in on sharding to get them\\n> accepted.\\n>\\n> June, 2015: I attended the PGCon sharding unconference session and\\n> there was a huge discussion about where we should go with sharding.\\n> I think the big take-away was that most people liked the FDW approach,\\n> but had business/customer reasons for wanting to work on XC or XL because\\n> those would be production-ready faster.\\n>\\n> July, 2015: Oleg Bartunov and his new company Postgres Professional (PP)\\n> started to think about joining the FDW approach, rather than working on\\n> XL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\\n> meeting is scheduled for September 1.\\n>\\n> August, 2015: While speaking at SFPUG, Citus Data approached me about\\n> joining the FDW sharding team. They have been invited to the September\\n> 1 meeting, as have the XC and XL people.\\n>\\n> October, 2015: EDB is sponsoring a free 3-hour summit about FDW sharding\\n> at the PG-EU conference in Vienna. Everyone is invited, but it is hoped\\n> most of the September 1 folks can attend.\\n>\\n> February, 2016: Oleg is planning a similar meeting at their February\\n> Moscow conference.\\n>\\n> Anyway, I wanted to explain the work that has been happening around\\n> sharding. As things move forward, I am increasingly convinced that write\\n> scaling will be needed soon, that the XC approach is the only reasonable\\n> way to do it, and that FDWs are the cleanest way to get it into community\\n> Postgres.\\n>\\n> --\\n> Bruce Momjian <bruce@momjian.us> http://momjian.us\\n> EnterpriseDB http://enterprisedb.com\\n>\\n> + Everyone has their own god. +\\n>\\n>\\n> --\\n> Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\n> To make changes to your subscription:\\n> http://www.postgresql.org/mailpref/pgsql-hackers\\n>\\n\\n\\n\\n-- \\n*Sumedh Pathak*\\nCitus Data\\n650.422.9797\\nsumedh@citusdata.com\\n\\nHi Bruce,Sumedh from Citus Data here.> August, 2015: While speaking at SFPUG, Citus Data approached me about joining the FDW sharding team. They have been invited to the September 1 meeting, as have the XC and XL people.I'd like to add a clarification. We already tried the FDW APIs for pg_shard two years ago and failed. We figured sharing our learnings could contribute to the technical discussion and that's why we wanted to be in the call.Ozgun summarized our technical learnings in this design document: https://goo.gl/vJWF85In the document, we focused on one of the four learnings we had with FDW APIs. For us, we switched to the hook API based approach, and things went smoothly from there.Best,SumedhOn Sat, Aug 29, 2015 at 7:17 PM, Bruce Momjian <bruce@momjian.us> wrote:I have recently increased my public statements about the idea of adding\\nhorizontal scaling/sharding to Postgres. I wanted to share with hackers\\na timeline of how we got here, and where I think we are going in the\\nshort term:\\n\\n2012-2013: As part of writing my scaling talk\\n(http://momjian.us/main/presentations/overview.html#scaling), studying\\nOracle RAC, and talking to users, it became clear that an XC-like\\narchitecture (sharding) was the only architecture that was going to allow\\nfor write scaling.\\n\\nUsers and conference attendees I talked to were increasingly concerned\\nabout the ability of Postgres to scale for high write volumes. They didn't\\nnecessarily need that scale now, but they needed to know they could get\\nit if they wanted it, and wouldn't need to switch to a new database in\\nthe future. This is similar to wanting a car that can get you on a highway\\non-ramp fast --- even if you don't need it, you want to know it is there.\\n\\n2014: I started to shop around the idea that we could use FDWs,\\nparallelism, and a transaction/snapshot manager to get XC features\\nas built-in to Postgres. (I don't remember where the original idea\\ncame from.) It was clear that having separate forks of the source code\\nin XC and XL was never going to achieve critical mass --- there just\\naren't enough people who need high right scale right now, and the fork\\nmaintenance overhead is a huge burden.\\n\\nI realized that we would never get community acceptance to dump the XC\\n(or XL) code needed for sharding into community Postgres, but with FDWs,\\nwe could add the features as _part_ of improving FDWs, which would benefit\\nFDWs _and_ would be useful for sharding. (We already see some of those\\nFDW features in 9.5.)\\n\\nOctober, 2014: EDB and NTT started working together in the community\\nto start improving FDWs as a basis for an FDW-based sharding solution.\\nMany of the 9.5 FDW improvements that also benefit sharding were developed\\nby a combined EDB/NTT team. The features improved FDWs independent of\\nsharding, so they didn't need community buy-in on sharding to get them\\naccepted.\\n\\nJune, 2015: I attended the PGCon sharding unconference session and\\nthere was a huge discussion about where we should go with sharding.\\nI think the big take-away was that most people liked the FDW approach,\\nbut had business/customer reasons for wanting to work on XC or XL because\\nthose would be production-ready faster.\\n\\nJuly, 2015: Oleg Bartunov and his new company Postgres Professional (PP)\\nstarted to think about joining the FDW approach, rather than working on\\nXL, as they had stated at PGCon in June. A joint NTT/EDB/PP phone-in\\nmeeting is scheduled for September 1.\\n\\nAugust, 2015: While speaking at SFPUG, Citus Data approached me about\\njoining the FDW sharding team. They have been invited to the September\\n1 meeting, as have the XC and XL people.\\n\\nOctober, 2015: EDB is sponsoring a free 3-hour summit about FDW sharding\\nat the PG-EU conference in Vienna. Everyone is invited, but it is hoped\\nmost of the September 1 folks can attend.\\n\\nFebruary, 2016: Oleg is planning a similar meeting at their February\\nMoscow conference.\\n\\nAnyway, I wanted to explain the work that has been happening around\\nsharding. As things move forward, I am increasingly convinced that write\\nscaling will be needed soon, that the XC approach is the only reasonable\\nway to do it, and that FDWs are the cleanest way to get it into community\\nPostgres.\\n\\n--\\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n--\\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n-- Sumedh PathakCitus Data650.422.9797sumedh@citusdata.com\",\n \"msg_date\": \"Mon, 31 Aug 2015 16:28:37 -0700\",\n \"msg_from\": \"Sumedh Pathak <sumedh@citusdata.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 08/31/2015 02:47 PM, Robert Haas wrote:\\n> On Mon, Aug 31, 2015 at 4:16 PM, Josh Berkus <josh@agliodbs.com> wrote:\\n>> First, let me put out there that I think the horizontal scaling project\\n>> which has buy-in from the community and we're working on is infinitely\\n>> better than the one we're not working on or is an underresourced fork.\\n>> So we're in agreement on that. However, I think there's a lot of room\\n>> for discussion; I feel like the FDW approach was decided in exclusive\\n>> meetings involving a very small number of people. The FDW approach\\n>> *may* be the right approach, but I'd like to see some rigorous\\n>> questioning of that before it's final.\\n> \\n> It seems to me that sharding consists of (1) breaking your data set up\\n> into shards, (2) possibly replicating some of those shards onto\\n> multiple machines, and then (3) being able to access the remote data\\n> from local queries. As far as (1) is concerned, we need declarative\\n> partitioning, which is being worked on by Amit Langote. As far as (2)\\n> is concerned, I hope and expect BDR, or technology derived therefrom,\\n> to eventually fill that need. \\n\\nWell, maybe. If you look at pg_shard, you'll see that it works by\\nmultiplexing writes to all copies. There's a good reason to do that; it\\nallows you to have a tight feedback loop between the success of writes\\nand the availability of \\\"good\\\" nodes. If you're depending on a separate\\nreplication system to handle getting row copies from one shard to\\nanother, then you need a different way to deal with bad nodes and with\\ninconsistency between copies of shards. That's why the existing\\nmultinode non-relational databases don't separate replication from\\nwrites, either.\\n\\nFor that matter, if what you want is transactional fully ACID sharding,\\nI really don't see a way to do it via BDR, since BDR is purely\\nasynchronous replication, as far as I know.\\n\\nAlso, if we want BDR to do this, that's pretty far afield of what BDR is\\ncurrently capable of, so someone will need to put serious work into it\\nrather than just assuming functionality will show up.\\n\\n> As far as (3) is concerned, why\\n> wouldn't we use the foreign data wrapper interface, and specifically\\n> postgres_fdw? That interface was designed for the explicit purpose of\\n> allowing access to remote data sources, and a lot of work has been put\\n> into it, so it would be highly surprising if we decided to throw that\\n> away and develop something completely new from the ground up.\\n\\nWell, query hooks are also a capability which we already have, and is\\nmature. Citus has already posted about why they chose to use them instead.\\n\\nAs long as you recognize that the FDW API (not just the existing fdws)\\nwill need to expand to make this work, it's a viable path.\\n\\nAlso consider that (3) includes both reads and writes.\\n\\n> I think it's abundantly clear that we need a logical replication\\n> solution as part of any horizontal scalability story. People will\\n> want to do things like have 10 machines with each piece of data on 3\\n> of them, and there won't be any reasonable way of doing that without\\n> logical replication. I assume that BDR, or some technology derived\\n> from it, will end up in core and solve that problem. I had actually\\n> hoped we were going to get that in 9.5, but it didn't happen that way.\\n> Still, I think that getting first single-master, and then eventually\\n> multi-master, logical replication in core is absolutely critical. And\\n> not just for sharding specifically: replicating your whole database to\\n> several nodes and load-balancing your clients across them isn't\\n> sharding, but it does give you read scalability and is a good fit for\\n> people with geographically dispersed data with good geographical\\n> locality. I think a lot of people will want that.\\n\\nWell, the latter thing is something which BDR is designed for, so all\\nthat needs to happen with that is getting the rest of the plumbing into\\ncore. Also documentation, packaging, productization, etc. But the\\nheavy lifting has already been done.\\n\\nHowever, integrating BDR with sharding has some major design issues\\nwhich aren't trivial and may be unresolvable, per above.\\n\\n> I'm not quite sure yet how we can marry declarative partitioning and\\n> better FDW-pushdown and logical replication into one seamless, easy to\\n> deploy solution that requires very low administrator effort. But I am\\n> sure that each of those things, taken individually, is very useful,\\n> and that being able to construct a solution from those building blocks\\n> would be a big improvement over what we have today. I can't imagine\\n> that trying to do one monolithic project that provides all of those\\n> things, but only if you combine them in the specific way that the\\n> designer had in mind, is ever going to be successful. People _will_\\n> want access to each of those features in an unbundled fashion. And,\\n> trying to do them altogether leads to trying to solve too many\\n> problems at once. I think the history of Postgres-XC is a cautionary\\n> tale there.\\n\\nYes. It's also a cautionary tale about not skipping over major design\\nelements (like HA and DR) until after version 1.0, which is one of the\\nreasons I'm harping on certain things here. I don't want us to repeat\\nthose mistakes.\\n\\n> I don't really understand how pg_shard fits into this equation. It\\n> looks to me like it does some interesting things but, for example, it\\n> doesn't support JOIN pushdown, and suggests that you use the\\n> proprietary CitusDB engine if you need that. But I think JOIN\\n> pushdown is something we want to have in core, not something where we\\n> want to point people to proprietary alternatives. And it has some\\n> restrictions on INSERT statements - they have to contain only values\\n> which are constants or which can be folded to constants. I'm just\\n> guessing, but I bet that's probably due to some limitation which\\n> pg_shard, being out of core, has difficulty overcoming, but we can do\\n> better in core. Basically I guess I expect much of what pg_shard does\\n> to be subsumed as we improve FDWs, but maybe not all of it.\\n\\npg_shard provides an alternate implementation based on planner hooks\\ninstead of FDWs. Even if you pursue an FDW-based design, you should\\nlook at (a) why the Citus team found FDWs to be unworkable and (b) what\\ngot implemented in planner hooks. Otherwise you're liable to repeat the\\nexact same \\\"learning experience\\\".\\n\\n-- \\nJosh Berkus\\nPostgreSQL Experts Inc.\\nhttp://pgexperts.com\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 31 Aug 2015 17:10:11 -0700\",\n \"msg_from\": \"Josh Berkus <josh@agliodbs.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 31, 2015 at 05:10:11PM -0700, Josh Berkus wrote:\\n> > As far as (3) is concerned, why\\n> > wouldn't we use the foreign data wrapper interface, and specifically\\n> > postgres_fdw? That interface was designed for the explicit purpose of\\n> > allowing access to remote data sources, and a lot of work has been put\\n> > into it, so it would be highly surprising if we decided to throw that\\n> > away and develop something completely new from the ground up.\\n> \\n> Well, query hooks are also a capability which we already have, and is\\n> mature. Citus has already posted about why they chose to use them instead.\\n> \\n> As long as you recognize that the FDW API (not just the existing fdws)\\n> will need to expand to make this work, it's a viable path.\\n\\nUh, we already have a list of things we need to add to FDWs to make them\\nwork, and Citus Data has provided a document of more things that are\\nneeded, https://goo.gl/vJWF85. I am not sure how much bigger a red flag\\nyou want to confirm that everyone agrees that major FDW improvements are\\na requirement for this. \\n\\nMy hope is that many FDW improvements will benefit sharding and\\nnon-sharding workloads, but I bet some improvements are going to be\\nsharding-specific. I would say we are still in the exploratory stage,\\nbut based on the number of people who care about this feature and want\\nto be involved, I think we are off to a very good start. :-)\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 31 Aug 2015 20:54:51 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"Bruce Momjian wrote:\\n\\n> My hope is that many FDW improvements will benefit sharding and\\n> non-sharding workloads, but I bet some improvements are going to be\\n> sharding-specific. I would say we are still in the exploratory stage,\\n> but based on the number of people who care about this feature and want\\n> to be involved, I think we are off to a very good start. :-)\\n\\nHaving lots of interested people doesn't help with some problems,\\nthough. The Citus document says:\\n\\n\\tAnd the issue with these four limitations wasn't with foreign\\n\\tdata wrappers. We wrote mongo_fdw and cstore_fdw, and we're\\n\\tquite happy with the contract FDWs provide. The problem was that\\n\\twe were trying to retrofit an API for something that it was\\n\\tfundamentally not designed to do.\\n\\n-- \\n�lvaro Herrera http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Mon, 31 Aug 2015 23:23:58 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 2015/09/01 9:54, Bruce Momjian wrote:\\n> On Mon, Aug 31, 2015 at 05:10:11PM -0700, Josh Berkus wrote:\\n>>> As far as (3) is concerned, why\\n>>> wouldn't we use the foreign data wrapper interface, and specifically\\n>>> postgres_fdw? That interface was designed for the explicit purpose of\\n>>> allowing access to remote data sources, and a lot of work has been put\\n>>> into it, so it would be highly surprising if we decided to throw that\\n>>> away and develop something completely new from the ground up.\\n>>\\n>> Well, query hooks are also a capability which we already have, and is\\n>> mature. Citus has already posted about why they chose to use them instead.\\n>>\\n>> As long as you recognize that the FDW API (not just the existing fdws)\\n>> will need to expand to make this work, it's a viable path.\\n>\\n> Uh, we already have a list of things we need to add to FDWs to make them\\n> work, and Citus Data has provided a document of more things that are\\n> needed, https://goo.gl/vJWF85.\\n\\nMy top priority is postgres_fdw join pushdown, but I also plan to work \\non update pushdown [1] for 9.6, which couldn't make it into 9.5. I \\nthink that would resolve the following issue mentioned in the document:\\n\\n\\tUPDATE and DELETE operations are performed by first fetching\\n\\trecords from the table scanning functions, and then going over\\n\\tthe fetched records. If the user wanted to update a single row,\\n\\tthis involved first pulling rows and then updating related\\n\\trecords.\\n\\nBest regards,\\nEtsuro Fujita\\n\\n[1] https://commitfest.postgresql.org/4/162/\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 01 Sep 2015 12:30:35 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 3:17 AM, Robert Haas <robertmhaas@gmail.com> wrote:\\n\\n>\\n>\\n> It seems to me that sharding consists of (1) breaking your data set up\\n> into shards, (2) possibly replicating some of those shards onto\\n> multiple machines, and then (3) being able to access the remote data\\n> from local queries. As far as (1) is concerned, we need declarative\\n> partitioning, which is being worked on by Amit Langote. As far as (2)\\n> is concerned, I hope and expect BDR, or technology derived therefrom,\\n> to eventually fill that need. As far as (3) is concerned, why\\n> wouldn't we use the foreign data wrapper interface, and specifically\\n> postgres_fdw? That interface was designed for the explicit purpose of\\n> allowing access to remote data sources, and a lot of work has been put\\n> into it, so it would be highly surprising if we decided to throw that\\n> away and develop something completely new from the ground up.\\n>\\n> It's true that postgres_fdw doesn't do everything we need yet. The\\n> new join pushdown hooks aren't used by postgres_fdw yet, and the API\\n> itself has some bugs with EvalPlanQual handling. Aggregate pushdown\\n> is waiting on upper planner path-ification. DML pushdown doesn't\\n> exist yet, and the hooks that would enable pushdown of ORDER BY\\n> clauses to the remote side aren't being used by postgres_fdw. But all\\n> of these things have been worked on. Patches for many of them have\\n> already been posted. They have suffered from a certain amount of\\n> neglect by senior hackers, and perhaps also from a shortage of time on\\n> the part of the authors. But an awful lot of the work that is needed\\n> here has already been done, if only we could get it committed.\\n> Aggregate pushdown is a notable exception, but abandoning the foreign\\n> data wrapper approach in favor of something else won't fix that.\\n>\\n> Postgres-XC developed a purpose-built system for talking to other\\n> nodes instead of using the FDW interface, for the very good reason\\n> that the FDW interface did not yet exist at the time that Postgres-XC\\n> was created. But several people associated with the XC project have\\n> said, including one on this thread, that if it had existed, they\\n> probably would have used it. And it's hard to see why you wouldn't:\\n> with XC's approach, the remote data source is presumed to be\\n> PostgreSQL (or Postgres-XC/XL/X2/whatever); and you can only use the\\n> facility as part of a sharding solution. The FDW interface can talk\\n> to anything, and it can be used for stuff other than sharding, like\\n> making one remote table appear local because you just happen to want\\n> that for some reason. This makes the XC approach look rather brittle\\n> by comparison. I don't blame the XC folks for taking the shortest\\n> path between two points, but FDWs are better, and we ought to try to\\n> leverage that.\\n>\\n>\\nIn my discussions on this topic with various folks including Robert, I've\\nconceded that if FDW was available when XC was first written, in all\\nlikelihood we would have used and extended that interface. But that wasn't\\nthe case and we did what we thought was the best solution at that time,\\ngiven the resources and the schedule. To be honest, when XC project was\\nstarted, I was quite skeptical about the whole thing given the goal was to\\nbuilt something which can replace Oracle RAC with may be less than 1%\\nresources of what Oracle must have invested in building RAC. The lack of\\nresources at the start of the project keeps showing up in the quality\\nissues that users report from time to time. Having said that, I am quite\\nsatisfied with what we have been able to build within the constraints.\\n\\nBut FDW is just one part of the story. There is this entire global\\nconsistency problem that would require something like GTM to give out XIDs\\nand snapshots, atomicity which would require managing transactions across\\nmultiple shards, join pushdowns when all data is not available locally,\\nsomething that XL is attempting to solve with datanode-datanode exchange of\\ninformation, other global states such as sequences, replicating some part\\nof the data to multiple shards for efficient operations, ability to\\nadd/remove shards with least disruption, globally consistent\\nbackups/restore. XC/XL has attempted to solve each of them to some extent.\\nI don't claim that they are completely solved and there are no corner cases\\nleft, but we have made fairly good progress on each of them.\\n\\nMy worry is that if we start implementing them again from scratch, it will\\ntake a few years before we get them in a usable state. What XC/XL lacked is\\nprobably a Robert Haas or a Tom Lane who could look at the work and suggest\\nmajor edits. If that had happened, the quality of the product could have\\nbeen much better today. I don't mean to derate the developers who worked on\\nXC/XL, but there is no harm in accepting that if someone with a much better\\nunderstanding of the whole system was part of the team, that would have\\npositively impacted the project. Is that an angle worth exploring? Does it\\nmake sense to commit some more resources to say XC or XL and try to improve\\nthe quality of the product even further? To be honest, XL is in far far\\nbetter shape (haven't really tried XC in a while) and some more\\nQA/polishing can make it production ready much sooner.\\n\\nYet another possibility is rework the design such that only coordinator\\nneeds to be a fork of PostgreSQL but the shards are all PostgreSQL\\ninstances, queried using standard client APIs. That would reduce the code\\nthat needs to go in the core to build the entire scalable system and also\\nshorten the timeline considerably.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Tue, Sep 1, 2015 at 3:17 AM, Robert Haas <robertmhaas@gmail.com> wrote:\\n\\nIt seems to me that sharding consists of (1) breaking your data set up\\ninto shards, (2) possibly replicating some of those shards onto\\nmultiple machines, and then (3) being able to access the remote data\\nfrom local queries. As far as (1) is concerned, we need declarative\\npartitioning, which is being worked on by Amit Langote. As far as (2)\\nis concerned, I hope and expect BDR, or technology derived therefrom,\\nto eventually fill that need. As far as (3) is concerned, why\\nwouldn't we use the foreign data wrapper interface, and specifically\\npostgres_fdw? That interface was designed for the explicit purpose of\\nallowing access to remote data sources, and a lot of work has been put\\ninto it, so it would be highly surprising if we decided to throw that\\naway and develop something completely new from the ground up.\\n\\nIt's true that postgres_fdw doesn't do everything we need yet. The\\nnew join pushdown hooks aren't used by postgres_fdw yet, and the API\\nitself has some bugs with EvalPlanQual handling. Aggregate pushdown\\nis waiting on upper planner path-ification. DML pushdown doesn't\\nexist yet, and the hooks that would enable pushdown of ORDER BY\\nclauses to the remote side aren't being used by postgres_fdw. But all\\nof these things have been worked on. Patches for many of them have\\nalready been posted. They have suffered from a certain amount of\\nneglect by senior hackers, and perhaps also from a shortage of time on\\nthe part of the authors. But an awful lot of the work that is needed\\nhere has already been done, if only we could get it committed.\\nAggregate pushdown is a notable exception, but abandoning the foreign\\ndata wrapper approach in favor of something else won't fix that.\\n\\nPostgres-XC developed a purpose-built system for talking to other\\nnodes instead of using the FDW interface, for the very good reason\\nthat the FDW interface did not yet exist at the time that Postgres-XC\\nwas created. But several people associated with the XC project have\\nsaid, including one on this thread, that if it had existed, they\\nprobably would have used it. And it's hard to see why you wouldn't:\\nwith XC's approach, the remote data source is presumed to be\\nPostgreSQL (or Postgres-XC/XL/X2/whatever); and you can only use the\\nfacility as part of a sharding solution. The FDW interface can talk\\nto anything, and it can be used for stuff other than sharding, like\\nmaking one remote table appear local because you just happen to want\\nthat for some reason. This makes the XC approach look rather brittle\\nby comparison. I don't blame the XC folks for taking the shortest\\npath between two points, but FDWs are better, and we ought to try to\\nleverage that.\\nIn my discussions on this topic with various folks including Robert, I've conceded that if FDW was available when XC was first written, in all likelihood we would have used and extended that interface. But that wasn't the case and we did what we thought was the best solution at that time, given the resources and the schedule. To be honest, when XC project was started, I was quite skeptical about the whole thing given the goal was to built something which can replace Oracle RAC with may be less than 1% resources of what Oracle must have invested in building RAC. The lack of resources at the start of the project keeps showing up in the quality issues that users report from time to time. Having said that, I am quite satisfied with what we have been able to build within the constraints. But FDW is just one part of the story. There is this entire global consistency problem that would require something like GTM to give out XIDs and snapshots, atomicity which would require managing transactions across multiple shards, join pushdowns when all data is not available locally, something that XL is attempting to solve with datanode-datanode exchange of information, other global states such as sequences, replicating some part of the data to multiple shards for efficient operations, ability to add/remove shards with least disruption, globally consistent backups/restore. XC/XL has attempted to solve each of them to some extent. I don't claim that they are completely solved and there are no corner cases left, but we have made fairly good progress on each of them. My worry is that if we start implementing them again from scratch, it will take a few years before we get them in a usable state. What XC/XL lacked is probably a Robert Haas or a Tom Lane who could look at the work and suggest major edits. If that had happened, the quality of the product could have been much better today. I don't mean to derate the developers who worked on XC/XL, but there is no harm in accepting that if someone with a much better understanding of the whole system was part of the team, that would have positively impacted the project. Is that an angle worth exploring? Does it make sense to commit some more resources to say XC or XL and try to improve the quality of the product even further? To be honest, XL is in far far better shape (haven't really tried XC in a while) and some more QA/polishing can make it production ready much sooner.Yet another possibility is rework the design such that only coordinator needs to be a fork of PostgreSQL but the shards are all PostgreSQL instances, queried using standard client APIs. That would reduce the code that needs to go in the core to build the entire scalable system and also shorten the timeline considerably.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Tue, 1 Sep 2015 09:30:41 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 2015-08-31 20:54:51 -0400, Bruce Momjian wrote:\\n> Uh, we already have a list of things we need to add to FDWs to make them\\n> work, and Citus Data has provided a document of more things that are\\n> needed, https://goo.gl/vJWF85. I am not sure how much bigger a red flag\\n> you want to confirm that everyone agrees that major FDW improvements are\\n> a requirement for this.\\n\\nSeveral people saying that the FDW infrastructure isn't sufficient right\\nnow is pretty far from implying that all of them agree that the FDW API\\nis the way to go.\\n\\nI'm not sure myself. If it works out it's going to save us some work and\\nmake it more realistic to get there sometime not too far off. But I'm\\nafraid that the resulting system will feel like our current partitioning\\nimplemenentation. Yes, it kinda works, but it's hard to get started, it\\ndoesn't support too many features and you're kind afraid your relatives\\nwill see what you've done.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 10:15:27 +0200\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 31, 2015 at 01:16:21PM -0700, Josh Berkus wrote:\\n> I'm also going to pontificate that, for a future solution, we should not\\n> focus on write *IO*, but rather on CPU and RAM. The reason for this\\n> thinking is that, with the latest improvements in hardware and 9.5\\n> improvements, it's increasingly rare for machines to be bottlenecked on\\n> writes to the transaction log (or the heap). This has some implications\\n> for system design. For example, solutions which require all connections\\n> to go through a single master node do not scale sufficiently to be worth\\n> bothering with.\\n\\nWell, I highlighted write IO for sharding because sharding is the only\\nsolution that allows write scaling. If we want to scale CPU, we are\\nbetter off using server parallelism, and to scale CPU and RAM, a\\nmulti-master/BDR solution seems best. (Multi-master doesn't do write\\nscaling because you eventually have to write all the data to each node.)\\n\\nFor read-scaling, having the read queries go to streaming slave seems\\nbest.\\n\\nOnly sharding allows for write scaling, but only in very limited\\nuse-cases, where the queries use multiple shards and the\\nsharding/communication overhead doesn't overwhelm the benefits.\\n\\nFor these reasons, I think sharding has a limited use, and hence, I\\ndon't think the community will be willing to add a lot of code just to\\nenable auto-sharding. I think it has to be done in a way that adding\\nsharding also gives other benefits, like better FDWs and cross-node ACID\\ncontrol.\\n\\nIn summary, I don't think adding a ton of code just to do sharding will\\nbe acceptable. A corollary of that, is that if FDWs are unable to\\nprovide useful sharding, I don't see an acceptable way of adding\\nbuilt-in sharding to Postgres.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 05:39:09 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 10:15:27AM +0200, Andres Freund wrote:\\n> On 2015-08-31 20:54:51 -0400, Bruce Momjian wrote:\\n> > Uh, we already have a list of things we need to add to FDWs to make them\\n> > work, and Citus Data has provided a document of more things that are\\n> > needed, https://goo.gl/vJWF85. I am not sure how much bigger a red flag\\n> > you want to confirm that everyone agrees that major FDW improvements are\\n> > a requirement for this.\\n> \\n> Several people saying that the FDW infrastructure isn't sufficient right\\n> now is pretty far from implying that all of them agree that the FDW API\\n> is the way to go.\\n> \\n> I'm not sure myself. If it works out it's going to save us some work and\\n> make it more realistic to get there sometime not too far off. But I'm\\n> afraid that the resulting system will feel like our current partitioning\\n> implemenentation. Yes, it kinda works, but it's hard to get started, it\\n> doesn't support too many features and you're kind afraid your relatives\\n> will see what you've done.\\n\\nWell, reworking our partitioning system is one of the things required\\nfor sharding, so at least we will clean up one mess while we create\\nanother. ;-)\\n\\nSeem my post to Josh Berkus just now --- I think if we don't use FDWs,\\nthat sharding is such a limited use-case that we will not implement it\\ninside of Postgres.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 05:41:55 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 09:30:41AM +0530, Pavan Deolasee wrote:\\n> My worry is that if we start implementing them again from scratch, it will take\\n> a few years before we get them in a usable state. What XC/XL lacked is probably\\n> a Robert Haas or a Tom Lane who could look at the work and suggest major edits.\\n> If that had happened, the quality of the product could have been much better\\n> today. I don't mean to derate the developers who worked on XC/XL, but there is\\n> no harm in accepting that if someone with a much better understanding of the\\n> whole system was part of the team, that would have positively impacted the\\n> project. Is that an angle worth exploring? Does it make sense to commit some\\n> more resources to say XC or XL and try to improve the quality of the product\\n> even further? To be honest, XL is in far far better shape (haven't really tried\\n> XC in a while) and some more QA/polishing can make it production ready much\\n> sooner.\\n\\nThere is no question that using XC/XL will get us to a usable solution\\nfaster, but see my recent post to Josh Berkus --- the additional code\\nwill be so burdensome that I doubt it would be accepted. If it was, I\\nbet we would have considered it long ago.\\n\\nI think the only way we are going to get sharding into Postgres is to do\\nit in a way that enhances existing Postgres capabilities. \\n\\n(I think we got a little too cute in enhancing existing Postgres\\ncapabilities to add partitioning, and I think we need to fix that.\\nHopefully we don't do the same thing with sharding.)\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 05:48:35 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 01/09/15 21:41, Bruce Momjian wrote:\\n>\\n> Well, reworking our partitioning system is one of the things required\\n> for sharding, so at least we will clean up one mess while we create\\n> another. ;-)\\n>\\n> Seem my post to Josh Berkus just now --- I think if we don't use FDWs,\\n> that sharding is such a limited use-case that we will not implement it\\n> inside of Postgres.\\n>\\n\\nI'm thinking that partitioning and sharding are two different things:\\n\\nPartitioning is about reducing the amount of table data accessed and \\nalso perhaps easing admin activities (archiving/removing old stuff etc).\\n\\nSharding is a about parallelism and redundancy...copies of stuff in \\ndifferent places and concurrent access by virtue of it being on \\ndifferent nodes!\\n\\nNow *maybe* FDW is a good way to approach this, but really would be nice \\nto see a more rigorous analysis (I note that like XC and XL, Greenplum \\nlooked at the existing mechanisms around at the time and ended up \\nwriting their own). Now I'm aware that things have moved on - but I \\nthink there needs to be a proper discussion about design and what we \\nthink distributed data/sharding etc should provide *before* grabbing \\nhold of FDW as *the answer*!\\n\\nRegards\\n\\nMark\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 21:58:11 +1200\",\n \"msg_from\": \"Mark Kirkwood <mark.kirkwood@catalyst.net.nz>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 31, 2015 at 3:08 PM, Alexander Korotkov <\\na.korotkov@postgrespro.ru> wrote:\\n\\n> On Mon, Aug 31, 2015 at 9:48 PM, Mason S <masonlists@gmail.com> wrote:\\n>\\n>>\\n>>> We also a bit disappointed by Huawei position about CSN patch, we hoped\\n>>> to use for our XTM.\\n>>>\\n>>\\n>> Disappointed in what way? Moving to some sort of CSN approach seems to\\n>> open things up for different future ideas. In the short term, it would mean\\n>> replacing potentially large snapshots and longer visibility checks. In the\\n>> long term, perhaps CSN could help simplify the design of multi-master\\n>> replication schemes.\\n>>\\n>\\n> We are disappointed because at PGCon talk Huawei announced publishing of\\n> their CSN patch and further work in this direction together with community.\\n> However, it's even not published yet despite all the promises. Nobody from\\n> Huawei answers CSN thread in the hackers.\\n> So, I think we got nothing from Huawei except teasing and should rely only\\n> on ourselves. That is disappointing.\\n>\\n>\\nOh, I see. I was in contact with some of the folks involved a few weeks\\nago. The intention is to do a bit more work on the patch and then post it.\\nThis should be happening \\\"soon\\\".\\n\\nThanks,\\n\\nMason\\n\\nOn Mon, Aug 31, 2015 at 3:08 PM, Alexander Korotkov <a.korotkov@postgrespro.ru> wrote:On Mon, Aug 31, 2015 at 9:48 PM, Mason S <masonlists@gmail.com> wrote: We also a bit disappointed by Huawei position about CSN patch, we hoped to use for our XTM. Disappointed in what way? Moving to some sort of CSN approach seems to open things up for different future ideas. In the short term, it would mean replacing potentially large snapshots and longer visibility checks. In the long term, perhaps CSN could help simplify the design of multi-master replication schemes. We are disappointed because at PGCon talk Huawei announced publishing of their CSN patch and further work in this direction together with community. However, it's even not published yet despite all the promises. Nobody from Huawei answers CSN thread in the hackers.So, I think we got nothing from Huawei except teasing and should rely only on ourselves. That is disappointing.Oh, I see. I was in contact with some of the folks involved a few weeks ago. The intention is to do a bit more work on the patch and then post it. This should be happening \\\"soon\\\".Thanks,Mason\",\n \"msg_date\": \"Tue, 1 Sep 2015 06:47:21 -0400\",\n \"msg_from\": \"Mason S <masonlists@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 31, 2015 at 11:23:58PM -0300, Alvaro Herrera wrote:\\n> Bruce Momjian wrote:\\n> \\n> > My hope is that many FDW improvements will benefit sharding and\\n> > non-sharding workloads, but I bet some improvements are going to be\\n> > sharding-specific. I would say we are still in the exploratory stage,\\n> > but based on the number of people who care about this feature and want\\n> > to be involved, I think we are off to a very good start. :-)\\n> \\n> Having lots of interested people doesn't help with some problems,\\n> though. The Citus document says:\\n> \\n> \\tAnd the issue with these four limitations wasn't with foreign\\n> \\tdata wrappers. We wrote mongo_fdw and cstore_fdw, and we're\\n> \\tquite happy with the contract FDWs provide. The problem was that\\n> \\twe were trying to retrofit an API for something that it was\\n> \\tfundamentally not designed to do.\\n\\nI had a chance to review the Citus Data document just now:\\n\\n\\thttps://goo.gl/vJWF85\\n\\nParticularly, it links to this document, which is clearer about the\\nissues they are trying to solve:\\n\\n\\thttps://www.citusdata.com/blog/114-how-to-build-your-distributed-database\\n\\nThe document opens a big question --- when queries can't be processed in\\na traditional top/down fashion, Citus has the goal of sending groups of\\nresults up the the coordinator, reordering them, then sending them back\\nto the shards for further processing, basically using the shards as\\ncompute engines because the shards are no longer using local data to do\\ntheir computations. The two examples they give are COUNT(DISTINCT) and\\na join across two sharded tables (\\\"CANADA\\\").\\n\\nI assumed these queries were going to be solved by sending as digested\\ndata as possible to the coordinator, and having the coordinator complete\\nany remaining processing. I think we are going to need to decide if\\nsuch \\\"sending data back to shards\\\" is something we are ever going to\\nimplement. I can see FDWs _not_ working well for that use-case.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 06:55:27 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 6:55 AM, Bruce Momjian <bruce@momjian.us> wrote:\\n\\n> On Mon, Aug 31, 2015 at 11:23:58PM -0300, Alvaro Herrera wrote:\\n> > Bruce Momjian wrote:\\n> >\\n> > > My hope is that many FDW improvements will benefit sharding and\\n> > > non-sharding workloads, but I bet some improvements are going to be\\n> > > sharding-specific. I would say we are still in the exploratory stage,\\n> > > but based on the number of people who care about this feature and want\\n> > > to be involved, I think we are off to a very good start. :-)\\n> >\\n> > Having lots of interested people doesn't help with some problems,\\n> > though. The Citus document says:\\n> >\\n> > And the issue with these four limitations wasn't with foreign\\n> > data wrappers. We wrote mongo_fdw and cstore_fdw, and we're\\n> > quite happy with the contract FDWs provide. The problem was that\\n> > we were trying to retrofit an API for something that it was\\n> > fundamentally not designed to do.\\n>\\n> I had a chance to review the Citus Data document just now:\\n>\\n> https://goo.gl/vJWF85\\n>\\n> Particularly, it links to this document, which is clearer about the\\n> issues they are trying to solve:\\n>\\n>\\n> https://www.citusdata.com/blog/114-how-to-build-your-distributed-database\\n>\\n> The document opens a big question --- when queries can't be processed in\\n> a traditional top/down fashion, Citus has the goal of sending groups of\\n> results up the the coordinator, reordering them, then sending them back\\n> to the shards for further processing, basically using the shards as\\n> compute engines because the shards are no longer using local data to do\\n> their computations. The two examples they give are COUNT(DISTINCT) and\\n> a join across two sharded tables (\\\"CANADA\\\").\\n>\\n> I assumed these queries were going to be solved by sending as digested\\n> data as possible to the coordinator, and having the coordinator complete\\n> any remaining processing. I think we are going to need to decide if\\n> such \\\"sending data back to shards\\\" is something we are ever going to\\n> implement. I can see FDWs _not_ working well for that use-case.\\n>\\n>\\nFor efficient internodes joins with row shipping, FDWs may also not be easy\\nto do. Maybe it is possible if we optionally pass in lists of other nodes\\nand information about how they are partitioned so data knows where to get\\nshipped.\\n\\nA challenge for planning with arbitrary copies of different shards is that\\nsometimes you may be able to push down joins, sometimes not. Planning and\\nexecution get ugly. Maybe this can be simplified by parent-child tables\\nfollowing the same partitioning scheme.\\n\\nMason\\n\\nOn Tue, Sep 1, 2015 at 6:55 AM, Bruce Momjian <bruce@momjian.us> wrote:On Mon, Aug 31, 2015 at 11:23:58PM -0300, Alvaro Herrera wrote:\\n> Bruce Momjian wrote:\\n>\\n> > My hope is that many FDW improvements will benefit sharding and\\n> > non-sharding workloads, but I bet some improvements are going to be\\n> > sharding-specific. I would say we are still in the exploratory stage,\\n> > but based on the number of people who care about this feature and want\\n> > to be involved, I think we are off to a very good start. :-)\\n>\\n> Having lots of interested people doesn't help with some problems,\\n> though. The Citus document says:\\n>\\n> And the issue with these four limitations wasn't with foreign\\n> data wrappers. We wrote mongo_fdw and cstore_fdw, and we're\\n> quite happy with the contract FDWs provide. The problem was that\\n> we were trying to retrofit an API for something that it was\\n> fundamentally not designed to do.\\n\\nI had a chance to review the Citus Data document just now:\\n\\n https://goo.gl/vJWF85\\n\\nParticularly, it links to this document, which is clearer about the\\nissues they are trying to solve:\\n\\n https://www.citusdata.com/blog/114-how-to-build-your-distributed-database\\n\\nThe document opens a big question --- when queries can't be processed in\\na traditional top/down fashion, Citus has the goal of sending groups of\\nresults up the the coordinator, reordering them, then sending them back\\nto the shards for further processing, basically using the shards as\\ncompute engines because the shards are no longer using local data to do\\ntheir computations. The two examples they give are COUNT(DISTINCT) and\\na join across two sharded tables (\\\"CANADA\\\").\\n\\nI assumed these queries were going to be solved by sending as digested\\ndata as possible to the coordinator, and having the coordinator complete\\nany remaining processing. I think we are going to need to decide if\\nsuch \\\"sending data back to shards\\\" is something we are ever going to\\nimplement. I can see FDWs _not_ working well for that use-case.\\nFor efficient internodes joins with row shipping, FDWs may also not be easy to do. Maybe it is possible if we optionally pass in lists of other nodes and information about how they are partitioned so data knows where to get shipped. A challenge for planning with arbitrary copies of different shards is that sometimes you may be able to push down joins, sometimes not. Planning and execution get ugly. Maybe this can be simplified by parent-child tables following the same partitioning scheme.Mason\",\n \"msg_date\": \"Tue, 1 Sep 2015 07:01:35 -0400\",\n \"msg_from\": \"Mason S <masonlists@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 09/01/2015 02:48 AM, Bruce Momjian wrote:\\n> On Tue, Sep 1, 2015 at 09:30:41AM +0530, Pavan Deolasee wrote:\\n\\n> There is no question that using XC/XL will get us to a usable solution\\n> faster, but see my recent post to Josh Berkus --- the additional code\\n> will be so burdensome that I doubt it would be accepted. If it was, I\\n> bet we would have considered it long ago.\\n>\\n> I think the only way we are going to get sharding into Postgres is to do\\n> it in a way that enhances existing Postgres capabilities.\\n\\nSo that we have XL again?\\n\\nThis reads like: We don't want to merge a bunch of code that a non .Org \\nproject wrote. Instead we want to write a bunch of code that will all \\nbut duplicate what that other project wrote because.... ?\\n\\nDon't get me wrong, I am all about this goal and if XL truly doesn't fit \\nthat's cool but I think the idea that our project will somehow reinvent \\na better wheel is naive.\\n\\n> (I think we got a little too cute in enhancing existing Postgres\\n> capabilities to add partitioning, and I think we need to fix that.\\n> Hopefully we don't do the same thing with sharding.)\\n\\nNot cute, lazy. We implemented the barest minimum within our existing \\ninfrastructure and we have been kicking ourselves ever since.\\n\\nSincerely,\\n\\nJD\\n\\n\\n\\n-- \\nCommand Prompt, Inc. - http://www.commandprompt.com/ 503-667-4564\\nPostgreSQL Centered full stack support, consulting and development.\\nAnnouncing \\\"I'm offended\\\" is basically telling the world you can't\\ncontrol your own emotions, so everyone else should do it for you.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 08:18:38 -0700\",\n \"msg_from\": \"\\\"Joshua D. Drake\\\" <jd@commandprompt.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 09/01/2015 02:58 AM, Mark Kirkwood wrote:\\n> On 01/09/15 21:41, Bruce Momjian wrote:\\n\\n> I'm thinking that partitioning and sharding are two different things:\\n>\\n> Partitioning is about reducing the amount of table data accessed and\\n> also perhaps easing admin activities (archiving/removing old stuff etc).\\n>\\n> Sharding is a about parallelism and redundancy...copies of stuff in\\n> different places and concurrent access by virtue of it being on\\n> different nodes!\\n\\nIn our world, they are complimentary. Consider partitioning that uses \\nFDW tables with proper plan push down etc....\\n\\n>\\n> Now *maybe* FDW is a good way to approach this, but really would be nice\\n> to see a more rigorous analysis (I note that like XC and XL, Greenplum\\n> looked at the existing mechanisms around at the time and ended up\\n> writing their own). Now I'm aware that things have moved on - but I\\n> think there needs to be a proper discussion about design and what we\\n> think distributed data/sharding etc should provide *before* grabbing\\n> hold of FDW as *the answer*!\\n\\nAgreed.\\n\\nSincerely,\\n\\nJoshua D. Drake\\n\\n\\n\\n-- \\nCommand Prompt, Inc. - http://www.commandprompt.com/ 503-667-4564\\nPostgreSQL Centered full stack support, consulting and development.\\nAnnouncing \\\"I'm offended\\\" is basically telling the world you can't\\ncontrol your own emotions, so everyone else should do it for you.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 08:20:12 -0700\",\n \"msg_from\": \"\\\"Joshua D. Drake\\\" <jd@commandprompt.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 01, 2015 at 10:15:27AM +0200, Andres Freund wrote:\\n> On 2015-08-31 20:54:51 -0400, Bruce Momjian wrote:\\n> > Uh, we already have a list of things we need to add to FDWs to make them\\n> > work, and Citus Data has provided a document of more things that are\\n> > needed, https://goo.gl/vJWF85. I am not sure how much bigger a red flag\\n> > you want to confirm that everyone agrees that major FDW improvements are\\n> > a requirement for this.\\n> \\n> Several people saying that the FDW infrastructure isn't sufficient right\\n> now is pretty far from implying that all of them agree that the FDW API\\n> is the way to go.\\n> \\n> I'm not sure myself. If it works out it's going to save us some work and\\n> make it more realistic to get there sometime not too far off. But I'm\\n> afraid that the resulting system will feel like our current partitioning\\n> implemenentation. Yes, it kinda works, but it's hard to get started, it\\n> doesn't support too many features and you're kind afraid your relatives\\n> will see what you've done.\\n\\nWhatever we decide on, we can only count on built-in multi-node being\\nadopted if all the needed bits needed ship with every PostgreSQL\\ninstallation. If we require people do Install More Software™ in order\\nto get a feature, we're going to lose a majority of our potential\\nbase.\\n\\nIf it turns out we need the PostgreSQL FDW, and I believe some\\nconsensus is starting to gel around that, I can see not installing it\\nin template1 by default. Even that's a questionable decision, as\\nmerely having the software in place does not credibly increase the\\nattack surface, and does up the installation procedures by a fallible\\nstep.\\n\\nCheers,\\nDavid.\\n-- \\nDavid Fetter <david@fetter.org> http://fetter.org/\\nPhone: +1 415 235 3778 AIM: dfetter666 Yahoo!: dfetter\\nSkype: davidfetter XMPP: david.fetter@gmail.com\\n\\nRemember to vote!\\nConsider donating to Postgres: http://www.postgresql.org/about/donate\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 08:54:05 -0700\",\n \"msg_from\": \"David Fetter <david@fetter.org>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 12:00 AM, Pavan Deolasee\\n<pavan.deolasee@gmail.com> wrote:\\n> My worry is that if we start implementing them again from scratch, it will\\n> take a few years before we get them in a usable state. What XC/XL lacked is\\n> probably a Robert Haas or a Tom Lane who could look at the work and suggest\\n> major edits. If that had happened, the quality of the product could have\\n> been much better today. I don't mean to derate the developers who worked on\\n> XC/XL, but there is no harm in accepting that if someone with a much better\\n> understanding of the whole system was part of the team, that would have\\n> positively impacted the project. Is that an angle worth exploring? Does it\\n> make sense to commit some more resources to say XC or XL and try to improve\\n> the quality of the product even further? To be honest, XL is in far far\\n> better shape (haven't really tried XC in a while) and some more QA/polishing\\n> can make it production ready much sooner.\\n\\n From my point of view, and EnterpriseDB's point of view, anything that\\ndoesn't go into the core PostgreSQL distribution isn't really getting\\nus where we need to be. If there's code in XL that would be valuable\\nto merge into core PostgreSQL, then let's do it. If the code cannot\\nbe used but there are lessons we can learn that will make what does go\\ninto core PostgreSQL better, let's learn them. However, I don't think\\nit's serving anybody very well that we have the XC fork, and multiple\\nforks of the XC fork, floating around out there and people are working\\non those instead of working on core PostgreSQL. The reality is that\\nwe don't have enough brainpower to spread it across 2 or 3 or 4 or 5\\ndifferent projects and have all of them be good. The reality is,\\nalso, that horizontal scalability isn't an optional feature. There\\nwas a point in time at which the PostgreSQL project's official policy\\non replication was that it did not belong in core. That was a bad\\npolicy; thankfully, it was reversed, and the result was Hot Standby\\nand Streaming Replication, incredibly important technologies without\\nwhich we would not be where we are today. Horizontal scalability is\\njust as essential.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 12:08:05 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 4:15 AM, Andres Freund <andres@anarazel.de> wrote:\\n> On 2015-08-31 20:54:51 -0400, Bruce Momjian wrote:\\n>> Uh, we already have a list of things we need to add to FDWs to make them\\n>> work, and Citus Data has provided a document of more things that are\\n>> needed, https://goo.gl/vJWF85. I am not sure how much bigger a red flag\\n>> you want to confirm that everyone agrees that major FDW improvements are\\n>> a requirement for this.\\n>\\n> Several people saying that the FDW infrastructure isn't sufficient right\\n> now is pretty far from implying that all of them agree that the FDW API\\n> is the way to go.\\n>\\n> I'm not sure myself. If it works out it's going to save us some work and\\n> make it more realistic to get there sometime not too far off. But I'm\\n> afraid that the resulting system will feel like our current partitioning\\n> implemenentation. Yes, it kinda works, but it's hard to get started, it\\n> doesn't support too many features and you're kind afraid your relatives\\n> will see what you've done.\\n\\nI'm not averse to making the \\\"connect to the remote nodes\\\" part of\\nthis solution use something other than the FDW infrastructure at some\\npoint in time if somebody's prepared to build something better. On\\nthe other hand, I think it's extremely clear that the FDW\\ninfrastructure has a large amount of potential upon which we have\\nthoroughly failed to capitalize. Patches have already been written\\nfor UPDATE/DELETE pushdown and for join pushdown. Those patches have\\nbeen around for some time, but progress has been slow. Core\\ninfrastructure exists to allow sort pushdown, but nobody's done\\nanything with it. Aggregate pushdown hasn't happened yet due to the\\ndependency on upper planner path-ification, but it's not as if some\\nalternative to the FDW interface is going to dodge that problem.\\n\\nIt would be a bad idea to cling blindly to the FDW infrastructure if\\nit's fundamentally inadequate to do what we want. On the other hand,\\nit would also be a bad idea to set about recreating it without a\\nreally good reason, and - just to take one example - the fact that it\\ndoesn't currently push down DML operations to the remote side is not a\\nreally good reason to rewrite the whole thing. On the contrary, it's\\na reason to put some energy into the already-written patch which\\nimplements that optimization.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 12:18:43 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 09/01/2015 09:08 AM, Robert Haas wrote:\\n> On Tue, Sep 1, 2015 at 12:00 AM, Pavan Deolasee\\n\\n> From my point of view, and EnterpriseDB's point of view, anything that\\n> doesn't go into the core PostgreSQL distribution isn't really getting\\n> us where we need to be. If there's code in XL that would be valuable\\n> to merge into core PostgreSQL, then let's do it. If the code cannot\\n> be used but there are lessons we can learn that will make what does go\\n> into core PostgreSQL better, let's learn them.\\n\\nI think that is pretty much anybody in the industry's point of view and \\nI agree with it. Although there is definitely an argument to be had \\nabout whether it is a module or it is in core proper, no matter what it \\nshould be a .Org project.\\n\\nYou are also correct on the replication statement. Replication should \\nhave never been outside of core and I say that as the company that wrote \\na replication solution that even Fortune 50 companies used.\\n\\nI think that we should consider that there are very smart, very talented \\nengineers already devoting time to their respective communities (XL/XC) \\nthat may very much enjoy being part of our community so we don't have to \\nreinvent the wheel, again.\\n\\nJD\\n\\n-- \\nCommand Prompt, Inc. - http://www.commandprompt.com/ 503-667-4564\\nPostgreSQL Centered full stack support, consulting and development.\\nAnnouncing \\\"I'm offended\\\" is basically telling the world you can't\\ncontrol your own emotions, so everyone else should do it for you.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 09:40:18 -0700\",\n \"msg_from\": \"\\\"Joshua D. Drake\\\" <jd@commandprompt.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 6:55 AM, Bruce Momjian <bruce@momjian.us> wrote:\\n> I assumed these queries were going to be solved by sending as digested\\n> data as possible to the coordinator, and having the coordinator complete\\n> any remaining processing. I think we are going to need to decide if\\n> such \\\"sending data back to shards\\\" is something we are ever going to\\n> implement. I can see FDWs _not_ working well for that use-case.\\n\\nI do think we are going to want to support that. All the people I've\\ntalked to about parallel and distributed query processing agree that\\nyou need to do that sort of thing to get really good and scalable\\nperformance. I think that we could make a lot of headway as compared\\nwith the status quo just by implementing more pushdown optimizations\\nthan we have today. Right now, SELECT COUNT(*) FROM table will suck\\nback the whole remote table and count the rows locally, and that's\\nstupid. We can fix that case with better pushdown logic. We can also\\nfix the case of N-way join nests where the joins are either on the\\npartitioning key or to replicated tables. But suppose you have a join\\nbetween two tables which are sharded across the cluster but not on the\\npartitioning key. There's no way to push the join down, so all the\\nwork comes back to the coordinator, which is possibly OK if such\\nqueries are rare, but not so hot if they are frequent.\\n\\nTo leverage the full CPU power of the cluster in such a case, you need\\nto be able to shuffle data around between the nodes. You pick one of\\nthe two tables being joined, and based on the partitioning key of that\\ntable, each node examines the other table and, for each row, sends it\\nto the machine where it MIGHT have one or more join partners. Then\\neach node can join its shard of the first table against the rows from\\nthe second table that were sent to it.\\n\\nNow the question is, where should the code that does all of this live?\\n postgres_fdw? Some new, sharding-specific FDW? In core? I don't\\nknow for sure, but what I do know is that we could make a lot of\\nprogress over where we are today by just improving postgres_fdw, and I\\ndon't think those improvements are even all that difficult. If we\\ndecide we need to implement something new, it's going to be a huge\\nproject that will take years to complete, with uncertain results. I'd\\nrather have a postgres_fdw-based implementation that is imperfect and\\ncan't handle some kinds of queries in 9.6 than a promise that by 9.9\\nwe'll have something really great that handles MPP perfectly.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 12:40:40 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 7:01 AM, Mason S <masonlists@gmail.com> wrote:\\n> For efficient internodes joins with row shipping, FDWs may also not be easy\\n> to do. Maybe it is possible if we optionally pass in lists of other nodes\\n> and information about how they are partitioned so data knows where to get\\n> shipped.\\n>\\n> A challenge for planning with arbitrary copies of different shards is that\\n> sometimes you may be able to push down joins, sometimes not. Planning and\\n> execution get ugly. Maybe this can be simplified by parent-child tables\\n> following the same partitioning scheme.\\n\\nThis gets at a problem which Ozgun also mentioned in his Google\\ndocument, and which I also discussed with Etsuro Fujita at PGCon: good\\nquery planning requires good metadata, and we don't really have that\\ntoday.\\n\\nI think that a big part of the goal of the declarative partitioning\\nwork that Amit Langote has recently been undertaking is to provide a\\ncatalog representation of the partitioning structure that is easy to\\nwork with, as opposed to just having a bunch of CHECK constraints that\\nyou have to try to reason about. That's one part of the solution.\\n\\nYou also might need to know more about the remote table than is\\ncaptured by the column and data type list. Most particularly, you\\nmight want to know what indexes exist on the remote side, but\\ncurrently, to figure out that out, you'd need to send queries to\\nretrieve that information to the remote side every time you do\\nplanning, or maybe you could contrive a session-lifespan cache.\\nThat's pretty annoying.\\n\\nOne idea for solving this problem is to allow CREATE INDEX on foreign\\ntables, but I don't like that much. There's no guarantee that the\\nremote side is a PostgreSQL instance, and if it isn't, the relevant\\ndetails about the indexes that exist may not be convenient to\\nrepresent in our catalogs. Heck, that can be true even if it is a\\nPostgreSQL instance, if the remote side relies on an AM or a function\\nthat doesn't exist locally. But even if both sides are PostgreSQL\\ninstances using only btree indexes on raw columns, now you've put the\\nburden on the DBA to make sure that the index definitions on the local\\nand remote sides match, and that's a pain in the neck.\\n\\nWhat seems better to me is to allow ANALYZE of a foreign table a place\\nto record an arbitrary blob of metadata about the remote side that it\\ncan then get access to during planning. Then, you can record details\\nabout indexes, or statistics that don't fit into the mold of\\npg_statistic, or really, anything else you're going to need to figure\\nout the best plan, and if the DBA changes the configuration on the\\nremote side, they don't need to update the local configuration to\\nmatch; a re-ANALYZE will do the trick.\\n\\nI'm open to other ideas as well. Repartitioning will also arise for\\nan all-local parallel join, and it would be nice if the planner smarts\\ncould be shared between that case and the remote-table case.\\nTherefore, while I suspect that some of the logic here will end up\\ninside one or more FDWs, I'm pretty confident that a significant chunk\\nof it needs to go into the core optimizer.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 13:00:06 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 09/01/2015 02:39 AM, Bruce Momjian wrote:\\n> On Mon, Aug 31, 2015 at 01:16:21PM -0700, Josh Berkus wrote:\\n>> I'm also going to pontificate that, for a future solution, we should not\\n>> focus on write *IO*, but rather on CPU and RAM. The reason for this\\n>> thinking is that, with the latest improvements in hardware and 9.5\\n>> improvements, it's increasingly rare for machines to be bottlenecked on\\n>> writes to the transaction log (or the heap). This has some implications\\n>> for system design. For example, solutions which require all connections\\n>> to go through a single master node do not scale sufficiently to be worth\\n>> bothering with.\\n> \\n> Well, I highlighted write IO for sharding because sharding is the only\\n> solution that allows write scaling. If we want to scale CPU, we are\\n> better off using server parallelism, and to scale CPU and RAM, a\\n> multi-master/BDR solution seems best. (Multi-master doesn't do write\\n> scaling because you eventually have to write all the data to each node.)\\n\\nYou're assuming that our primary bottleneck for writes is IO. It's not\\nat present for most users, and it certainly won't be in the future. You\\nneed to move your thinking on systems resources into the 21st century,\\ninstead of solving the resource problems from 15 years ago.\\n\\nCurrently, CPU resources and locking are the primary bottlenecks on\\nwriting for the vast majority of the hundreds of servers I tune every\\nyear. This even includes AWS, with EBS's horrible latency; even in that\\nenvironment, most users can outstrip PostgreSQL's ability to handle\\nrequests by getting 20K PRIOPs.\\n\\nOur real future bottlenecks are:\\n\\n* ability to handle more than a few hundred connections\\n* locking limits on the scalability of writes\\n* ability to manage large RAM and data caches\\n\\n\\nThe only place where IO becomes the bottleneck is for the\\nbatch-processing, high-throughput DW case ... and I would argue that\\nexisting forks already handle that case.\\n\\nAny sharding solution worth bothering with will solve some or all of the\\nabove by extending our ability to process requests across multiple\\nnodes. Any solution which does not is merely an academic curiosity.\\n\\n> For these reasons, I think sharding has a limited use, and hence, I\\n> don't think the community will be willing to add a lot of code just to\\n> enable auto-sharding. I think it has to be done in a way that adding\\n> sharding also gives other benefits, like better FDWs and cross-node ACID\\n> control.\\n> \\n> In summary, I don't think adding a ton of code just to do sharding will\\n> be acceptable. A corollary of that, is that if FDWs are unable to\\n> provide useful sharding, I don't see an acceptable way of adding\\n> built-in sharding to Postgres.\\n\\nSo, while I am fully in agreement with you that having side benefits to\\nour sharding tools, I think you're missing the big picture entirely. In\\na few years, clustered/sharded PostgreSQL will be the default\\ninstallation, or we'll be a legacy database. Single-node and\\nsingle-master databases are rapidly becoming history.\\n\\n From my perspective, we don't need an awkward, limited, bolt-on solution\\nfor write-scaling. We need something which will become core to how\\nPostgreSQL works. I just don't see us getting there with the described\\nFDW approach, which is why I keep raising issues with it.\\n\\n-- \\nJosh Berkus\\nPostgreSQL Experts Inc.\\nhttp://pgexperts.com\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 01 Sep 2015 10:06:54 -0700\",\n \"msg_from\": \"Josh Berkus <josh@agliodbs.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 1:06 PM, Josh Berkus <josh@agliodbs.com> wrote:\\n> You're assuming that our primary bottleneck for writes is IO. It's not\\n> at present for most users, and it certainly won't be in the future. You\\n> need to move your thinking on systems resources into the 21st century,\\n> instead of solving the resource problems from 15 years ago.\\n\\nYour experience doesn't match mine. I find that it's frequently\\nimpossible to get the system to use all of the available CPU capacity,\\neither because you're bottlenecked on locks or because you are\\nbottlenecked on the I/O subsystem, and with the locking improvements\\nin newer versions, the former is becoming less and less common.\\nAmit's recent work on scalability demonstrates this trend: he goes\\nlooking for lock bottlenecks, and finds problems that only occur at\\n128+ concurrent connections running full tilt. The patches show\\nlimited benefit - a few percentage points - at lesser concurrency\\nlevels. Either there are other locking bottlenecks that limit\\nperformance at lower client counts but which mysteriously disappear as\\nconcurrency increases, which I would find surprising, or the limit is\\nsomewhere else. I haven't seen any convincing evidence that the I/O\\nsubsystem is the bottleneck, but I'm having a hard time figuring out\\nwhat else it could be.\\n\\n> Our real future bottlenecks are:\\n>\\n> * ability to handle more than a few hundred connections\\n> * locking limits on the scalability of writes\\n> * ability to manage large RAM and data caches\\n\\nI do agree that all of those things are problems, FWIW.\\n\\n> Any sharding solution worth bothering with will solve some or all of the\\n> above by extending our ability to process requests across multiple\\n> nodes. Any solution which does not is merely an academic curiosity.\\n\\nI think the right solution to those problems is to attack them\\nhead-on. Sharding solutions should cater to use cases where using all\\nthe resources of one machine isn't sufficient no matter how\\nefficiently we do it.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 13:17:36 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 09/01/2015 10:06 AM, Josh Berkus wrote:\\n> On 09/01/2015 02:39 AM, Bruce Momjian wrote:\\n>> On Mon, Aug 31, 2015 at 01:16:21PM -0700, Josh Berkus wrote:\\n\\n> Our real future bottlenecks are:\\n>\\n> * ability to handle more than a few hundred connections\\n\\nThis, 1000 times this. No a connection pooler doesn't help, we are using \\n1000 connections WITH a connection pooler. The amount of data centric, \\nalways connected (even if stateless) apps that are out there is \\nastounding. Our performance curve is better (especially since Robert's \\nfantastic work on 9.2) but it isn't where a lot of the demanding users \\nneed to be.\\n\\nWe are also seeing a vast uptick in always connected apps that aren't \\nweb centric (or the client at least isn't). In other words we are seeing \\nsituations where 1000 connections is 1000 users, connected.\\n\\nJD\\n\\n\\n\\n-- \\nCommand Prompt, Inc. - http://www.commandprompt.com/ 503-667-4564\\nPostgreSQL Centered full stack support, consulting and development.\\nAnnouncing \\\"I'm offended\\\" is basically telling the world you can't\\ncontrol your own emotions, so everyone else should do it for you.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 10:17:38 -0700\",\n \"msg_from\": \"\\\"Joshua D. Drake\\\" <jd@commandprompt.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 09/01/2015 10:17 AM, Robert Haas wrote:\\n> On Tue, Sep 1, 2015 at 1:06 PM, Josh Berkus <josh@agliodbs.com> wrote:\\n>> Any sharding solution worth bothering with will solve some or all of the\\n>> above by extending our ability to process requests across multiple\\n>> nodes. Any solution which does not is merely an academic curiosity.\\n> \\n> I think the right solution to those problems is to attack them\\n> head-on. Sharding solutions should cater to use cases where using all\\n> the resources of one machine isn't sufficient no matter how\\n> efficiently we do it.\\n\\nAs long as \\\"all the resources\\\" != \\\"just IO\\\", I'm completely on board\\nwith that. The reason I raised this is that the initial FDW-based\\nproposals pretty much scale IO and nothing else.\\n\\npg_shard also currently only scales IO, but they're working on that.\\n\\n-- \\nJosh Berkus\\nPostgreSQL Experts Inc.\\nhttp://pgexperts.com\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 01 Sep 2015 10:46:17 -0700\",\n \"msg_from\": \"Josh Berkus <josh@agliodbs.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nOn 09/01/2015 07:17 PM, Robert Haas wrote:\\n> On Tue, Sep 1, 2015 at 1:06 PM, Josh Berkus <josh@agliodbs.com> wrote:\\n>> You're assuming that our primary bottleneck for writes is IO. It's\\n>> not at present for most users, and it certainly won't be in the\\n>> future. You need to move your thinking on systems resources into\\n>> the 21st century, instead of solving the resource problems from 15\\n>> years ago.\\n>\\n> Your experience doesn't match mine. I find that it's frequently\\n> impossible to get the system to use all of the available CPU\\n> capacity, either because you're bottlenecked on locks or because you\\n> are bottlenecked on the I/O subsystem, and with the locking\\n> improvements in newer versions, the former is becoming less and less\\n> common. Amit's recent work on scalability demonstrates this trend: he\\n> goes looking for lock bottlenecks, and finds problems that only occur\\n> at 128+ concurrent connections running full tilt. The patches show\\n> limited benefit - a few percentage points - at lesser concurrency\\n> levels. Either there are other locking bottlenecks that limit\\n> performance at lower client counts but which mysteriously disappear\\n> as concurrency increases, which I would find surprising, or the limit\\n> is somewhere else. I haven't seen any convincing evidence that the\\n> I/O subsystem is the bottleneck, but I'm having a hard time figuring\\n> out what else it could be.\\n\\nMemory bandwidth, for example. It's quite difficult to spot, because the \\nintuition is that memory is fast, but thanks to improvements in storage \\n(and stagnation in RAM bandwidth), this is becoming a significant issue.\\n\\nProcess-management overhead is another thing we tend to ignore, but once \\nyou get to many processes all willing to work at the same time, you need \\nto account for that.\\n\\nOf course, this applies differently to different sharding use cases. For \\nexample analytics workloads have serious issues with memory bandwidth, \\nbut not so much with process management overhead (because the number of \\nconnections is usually about number of cores). Use cases with many \\nclients (in web-scale use cases) tends to run into both (all the \\nprocesses also have to share all the caches, killing them).\\n\\nI don't know if sharding can help solving (or at least improve) these \\nissues. And if sharding in general can, I don't know if it still holds \\nfor FDW-based solution.\\n\\nregards\\n\\n--\\nTomas Vondra http://www.2ndQuadrant.com\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 01 Sep 2015 20:04:18 +0200\",\n \"msg_from\": \"Tomas Vondra <tomas.vondra@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 2:04 PM, Tomas Vondra\\n<tomas.vondra@2ndquadrant.com> wrote:\\n> Memory bandwidth, for example. It's quite difficult to spot, because the\\n> intuition is that memory is fast, but thanks to improvements in storage (and\\n> stagnation in RAM bandwidth), this is becoming a significant issue.\\n\\nI'd appreciate any tips on how to spot problems of this type. But\\nit's my impression that perf, top, vmstat, and other Linux performance\\ntools will count time spent waiting for memory as CPU time, not idle\\ntime. If that's correct, that wouldn't explain workloads where CPU\\nutilization doesn't reach 100%. Rather, it would show up as CPU time\\nhitting 100% while tps remains low.\\n\\n> Process-management overhead is another thing we tend to ignore, but once you\\n> get to many processes all willing to work at the same time, you need to\\n> account for that.\\n\\nAny tips on spotting problems in that area?\\n\\nThanks,\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 14:11:21 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 2015-09-01 14:11:21 -0400, Robert Haas wrote:\\n> On Tue, Sep 1, 2015 at 2:04 PM, Tomas Vondra\\n> <tomas.vondra@2ndquadrant.com> wrote:\\n> > Memory bandwidth, for example. It's quite difficult to spot, because the\\n> > intuition is that memory is fast, but thanks to improvements in storage (and\\n> > stagnation in RAM bandwidth), this is becoming a significant issue.\\n> \\n> I'd appreciate any tips on how to spot problems of this type. But\\n> it's my impression that perf, top, vmstat, and other Linux performance\\n> tools will count time spent waiting for memory as CPU time, not idle\\n> time. If that's correct, that wouldn't explain workloads where CPU\\n> utilization doesn't reach 100%. Rather, it would show up as CPU time\\n> hitting 100% while tps remains low.\\n\\nYea.\\n\\n-e bus-cycles is a good start to measure where bus traffic is\\n relevant. Depending on the individual cpu other events can be helpful.\\n\\n> > Process-management overhead is another thing we tend to ignore, but once you\\n> > get to many processes all willing to work at the same time, you need to\\n> > account for that.\\n> \\n> Any tips on spotting problems in that area?\\n\\nNot perfect, but -e context-switches (general context switches) and -e\\nsyscalls:sys_enter_semop (for postgres enforced context switches) is\\nrather useful when combined with --call-graph dwarf ('fp' sometimes\\ndoesn't see through libc which is most of the time not compiled with\\n-fno-omit-frame-pointer).\\n\\nGreetings,\\n\\nAndres Freund\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 20:22:49 +0200\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nOn 08/31/2015 10:16 PM, Josh Berkus wrote:\\n> It's also important to recognize that there are three major use-cases\\n> for write-scalable clustering:\\n>\\n> * OLTP: small-medium cluster, absolute ACID consistency,\\n> bottlnecked on small writes per second\\n> * DW: small-large cluster, ACID optional,\\n> bottlenecked on bulk reads/writes\\n> * Web: medium to very large cluster, ACID optional,\\n> bottlenecked on # of connections\\n>\\n> We cannot possibly solve all of the above at once, but to the extent\\n> that we recognize all 3 use cases, we can build core features which\\n> can be adapted to all of them.\\n\\nIt would be good to have a discussion about use-cases first - each of us \\nis mostly concerned about the use cases they're dealing with, with \\nbottlenecks specific to their environment. These three basic use-cases \\nseem like a good start, but some of the details certainly don't match my \\nexperience ...\\n\\nFor example I can't see how ACID can be optional for the DWH use-case, \\nbut maybe there's a good explanation - I can imagine sacrificing various \\nACID properties at the node level, but I can't really imagine \\nsacrificing any of the ACID properties for the cluster as a whole. So \\nthis would deserve some explanation.\\n\\nI also don't share the view that write scalability is the only (or even \\nmain) issue, that we should aim to solve. For the business-intelligence \\nuse cases I've been working on recently, handling complex read-only \\nad-hoc queries is often much more important. And in those cases the \\nbottleneck is often CPU and/or RAM.\\n\\n>\\n> I'm also going to pontificate that, for a future solution, we should\\n> not focus on write *IO*, but rather on CPU and RAM. The reason for\\n> this thinking is that, with the latest improvements in hardware and\\n> 9.5 improvements, it's increasingly rare for machines to be\\n> bottlenecked on writes to the transaction log (or the heap). This has\\n> some implications for system design. For example, solutions which\\n> require all connections to go through a single master node do not\\n> scale sufficiently to be worth bothering with.\\n\\n+1\\n\\n> On some other questions from Mason:\\n>\\n>> Do we want multiple copies of shards, like the pg_shard approach? Or\\n>> keep things simpler and leave it up to the DBA to add standbys?\\n>\\n> We want multiple copies of shards created by the sharding system itself.\\n> Having a separate, and completely orthagonal, redundancy system to the\\n> sharding system is overly burdensome on the DBA and makes low-data-loss\\n> HA impossible.\\n\\nIMHO it'd be quite unfortunate if the design would make it impossible to \\ncombine those two features (e.g. creating standbys for shards and \\nfailing over to them).\\n\\nIt's true that solving HA at the sharding level (by keeping multiple \\ncopies of a each shard) may be simpler than combining sharding and \\nstandbys, but I don't see why it makes low-data-loss HA impossible.\\n\\n\\nregards\\n\\n--\\nTomas Vondra http://www.2ndQuadrant.com\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 01 Sep 2015 20:36:03 +0200\",\n \"msg_from\": \"Tomas Vondra <tomas.vondra@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nOn 09/01/2015 08:22 PM, Andres Freund wrote:\\n> On 2015-09-01 14:11:21 -0400, Robert Haas wrote:\\n>> On Tue, Sep 1, 2015 at 2:04 PM, Tomas Vondra\\n>> <tomas.vondra@2ndquadrant.com> wrote:\\n>>> Memory bandwidth, for example. It's quite difficult to spot, because the\\n>>> intuition is that memory is fast, but thanks to improvements in storage (and\\n>>> stagnation in RAM bandwidth), this is becoming a significant issue.\\n>>\\n>> I'd appreciate any tips on how to spot problems of this type. But\\n>> it's my impression that perf, top, vmstat, and other Linux performance\\n>> tools will count time spent waiting for memory as CPU time, not idle\\n>> time. If that's correct, that wouldn't explain workloads where CPU\\n>> utilization doesn't reach 100%. Rather, it would show up as CPU time\\n>> hitting 100% while tps remains low.\\n>\\n> Yea.\\n>\\n> -e bus-cycles is a good start to measure where bus traffic is\\n> relevant. Depending on the individual cpu other events can be helpful.\\n\\nlong-story: https://people.freebsd.org/~lstewart/articles/cpumemory.pdf\\n\\nIt's from 2007 and only explains oprofile (chapter 7), which is mostly \\nabandoned in favor of perf nowadays. Perf can produce similar stats, so \\nthe discussion is still valid. But it also shows cachegrind (valgrind \\nmodule).\\n\\nperf examples: http://www.brendangregg.com/perf.html\\n\\nMost of the examples with \\\"CPU\\\" in the comment are relevant. Usually \\n\\\"perf stat\\\" and \\\"perf stat -d\\\" are good starting points - once you get a \\nlot of LLC misses or too many instructions per cycle, it's a sign of \\nmemory bandwidth problems.\\n\\nSadly, this is partially caused by our volcano-style executor and \\nsharding alone can do nothing about that.\\n\\n>\\n>>> Process-management overhead is another thing we tend to ignore, but once you\\n>>> get to many processes all willing to work at the same time, you need to\\n>>> account for that.\\n>>\\n>> Any tips on spotting problems in that area?\\n>\\n> Not perfect, but -e context-switches (general context switches) and -e\\n> syscalls:sys_enter_semop (for postgres enforced context switches) is\\n> rather useful when combined with --call-graph dwarf ('fp' sometimes\\n> doesn't see through libc which is most of the time not compiled with\\n> -fno-omit-frame-pointer).\\n\\nRight, this is about the best I'm aware of.\\n\\nThe problem often is not in the number of context switches, but in the \\nfact that all the processes share the same (very limited) L caches on \\nthe CPU. Each process dirties the caches for the other processes, \\nlowering the hit ratios. Which can be spotted using the commands above.\\n\\nregards\\n\\n--\\nTomas Vondra http://www.2ndQuadrant.com\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 01 Sep 2015 20:59:11 +0200\",\n \"msg_from\": \"Tomas Vondra <tomas.vondra@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 09/01/2015 11:36 AM, Tomas Vondra wrote:\\n>> We want multiple copies of shards created by the sharding system itself.\\n>> Having a separate, and completely orthagonal, redundancy system to the\\n>> sharding system is overly burdensome on the DBA and makes low-data-loss\\n>> HA impossible.\\n> \\n> IMHO it'd be quite unfortunate if the design would make it impossible to\\n> combine those two features (e.g. creating standbys for shards and\\n> failing over to them).\\n> \\n> It's true that solving HA at the sharding level (by keeping multiple\\n> copies of a each shard) may be simpler than combining sharding and\\n> standbys, but I don't see why it makes low-data-loss HA impossible.\\n\\nOther way around, that is, having replication standbys as the only\\nmethod of redundancy requires either high data loss or high latency for\\nall writes.\\n\\nIn the case of async rep, every time we fail over a node, the entire\\ncluser would need to roll back to the last common known-good replay\\npoint, hence high data loss.\\n\\nIn the case of sync rep, we are required to wait for at least double\\nnetwork lag time in order to do a single write ... making\\nwrite-scalability quite difficult.\\n\\nFuther, if using replication the sharding system would have no way to\\n(a) find out immediately if a copy was bad and (b) fail over quickly to\\na copy of the shard if the first requested copy was not responding.\\nWith async replication, we also can't use multiple copies of the same\\nshard as a way to balance read workloads.\\n\\nIf we write to multiple copies as a part of the sharding feature, then\\nthat can be parallelized, so that we are waiting only as long as the\\nslowest write (or in failure cases, as long as the shard timeout).\\nFurther, we can check for shard-copy health and update shard\\navailability data with each user request, so that the ability to see\\nstale/bad data is minimized.\\n\\nThere are obvious problems with multiplexing writes, which you can\\nfigure out if you knock pg_shard around a bit. But I really think that\\nsolving those problems is the only way to go.\\n\\nMind you, I see a strong place for binary replication and BDR for\\nmulti-region redundancy; you really don't want that to be part of the\\nsharding system if you're aiming for write scalability.\\n\\n-- \\nJosh Berkus\\nPostgreSQL Experts Inc.\\nhttp://pgexperts.com\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 01 Sep 2015 12:19:40 -0700\",\n \"msg_from\": \"Josh Berkus <josh@agliodbs.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 3:19 PM, Josh Berkus <josh@agliodbs.com> wrote:\\n> Mind you, I see a strong place for binary replication and BDR for\\n> multi-region redundancy; you really don't want that to be part of the\\n> sharding system if you're aiming for write scalability.\\n\\nI mostly agree, but keep in mind that you don't have to replicate\\neverything. A lot of people might find it useful to replicate the\\ndata that is common to all nodes even if they don't replicate the\\nsharded data.\\n\\nAdmittedly, there are some problems with snapshots here: if you don't\\ndo anything special about snapshots, then what you have here will be\\n\\\"eventually consistent\\\" behavior. But that might be suitable for some\\nenvironments, such as very loosely coupled system where not all nodes\\nare connected all the time. And, for those environments where you do\\nneed consistent snapshots, we can imagine ways to get that behavior,\\nlike having the GTM consider the transaction uncommitted until it's\\nbeen logically replicated to every node.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 16:47:08 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nOn 09/01/2015 09:19 PM, Josh Berkus wrote:\\n> On 09/01/2015 11:36 AM, Tomas Vondra wrote:\\n>>> We want multiple copies of shards created by the sharding system\\n>>> itself. Having a separate, and completely orthagonal, redundancy\\n>>> system to the sharding system is overly burdensome on the DBA and\\n>>> makes low-data-loss HA impossible.\\n>>\\n>> IMHO it'd be quite unfortunate if the design would make it\\n>> impossible to combine those two features (e.g. creating standbys\\n>> for shards and failing over to them).\\n>>\\n>> It's true that solving HA at the sharding level (by keeping\\n>> multiple copies of a each shard) may be simpler than combining\\n>> sharding and standbys, but I don't see why it makes low-data-loss\\n>> HA impossible.\\n>\\n> Other way around, that is, having replication standbys as the only\\n> method of redundancy requires either high data loss or high latency\\n> for all writes.\\n\\nI haven't said that. I said that we should allow that topology, not that \\nit should be the only method of redundancy.\\n\\n>\\n> In the case of async rep, every time we fail over a node, the entire\\n> cluser would need to roll back to the last common known-good replay\\n> point, hence high data loss.\\n>\\n> In the case of sync rep, we are required to wait for at least double\\n> network lag time in order to do a single write ... making\\n> write-scalability quite difficult.\\n\\nWhich assumes that latency (or rather the increase due to syncrep) is a \\nproblem for the use case. Which may be the case for many use cases, but \\ncertainly is not a problem for many BI/DWH use cases performing mostly \\nlarge batch loads. In those cases the network bandwidth may be quite \\nimportant resource.\\n\\nFor example assume that there are just two shards in two separate data \\ncenters, connected by a link with limited bandwidth. Now, let's assume \\nyou always keep a local replica for failover. So you have A1+A2 in DC1, \\nB1+B2 in DC2. If you're in DC1, then writing data to B1 means you also \\nhave to write data to B2 and wait for it. So either you send the data to \\neach node separately (consuming 2x the bandwidth), or send it to B1 and \\nlet it propagate to B2 e.g. through sync rep.\\n\\nSo while you may be right in single-DC deployments, with multi-DC \\ndeployments the situation is quite different - not only that the network \\nbandwidth is not unlimited, but because latencies within DC may be a \\nfraction of latencies between the locations (to the extent that the \\nincrease due to syncrep may be just noise). So the local replication may \\nbe actually way faster.\\n\\nI can imagine forwarding the data between B1 and B2 even with a purely \\nsharding solution, but at that point you effectively re-implemented syncrep.\\n\\nIMHO the design has to address the multi-DC setups somehow. I think that \\nmany of the customers who are so concerned about scaling to many shards \\nare also concerned about availability in case of DC outages, no?\\n\\nWe should also consider support for custom topologies (not just a full \\nmesh, or whatever we choose as the default/initial topology), which is \\nsomehow related.\\n\\n>\\n> Futher, if using replication the sharding system would have no way\\n> to (a) find out immediately if a copy was bad and (b) fail over\\n> quickly to a copy of the shard if the first requested copy was not\\n> responding. With async replication, we also can't use multiple copies\\n> of the same shard as a way to balance read workloads.\\n\\nI don't follow. With sync rep we do know whether the copy is OK or not, \\nbecause the node either confirms writes or not. The failover certainly \\nis more complicated and is not immediate (to the extent of keeping a \\ncopy at the sharding level), but it's a question of trade-offs.\\n\\nIt's true we don't have auto-failover solution at the moment, but as I \\nsaid - I can easily imagine most people using just sharding, while some \\ndeployments use syncrep with manual failover.\\n\\n>\\n> If we write to multiple copies as a part of the sharding feature,\\n> then that can be parallelized, so that we are waiting only as long as\\n> the slowest write (or in failure cases, as long as the shard\\n> timeout). Further, we can check for shard-copy health and update\\n> shard availability data with each user request, so that the ability\\n> to see stale/bad data is minimized.\\n\\nAgain, this assumes infinite network bandwidth.\\n\\n>\\n> There are obvious problems with multiplexing writes, which you can\\n> figure out if you knock pg_shard around a bit. But I really think\\n> that solving those problems is the only way to go.\\n>\\n> Mind you, I see a strong place for binary replication and BDR for\\n> multi-region redundancy; you really don't want that to be part of\\n> the sharding system if you're aiming for write scalability.\\n\\nI haven't mentioned BDR at all, and given the async nature I don't have \\na clear idea of how it fits into the sharding world at this point.\\n\\nregards\\n\\n--\\nTomas Vondra http://www.2ndQuadrant.com\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 01 Sep 2015 23:29:52 +0200\",\n \"msg_from\": \"Tomas Vondra <tomas.vondra@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 08:18:38AM -0700, Joshua Drake wrote:\\n> On 09/01/2015 02:48 AM, Bruce Momjian wrote:\\n> >On Tue, Sep 1, 2015 at 09:30:41AM +0530, Pavan Deolasee wrote:\\n> \\n> >There is no question that using XC/XL will get us to a usable solution\\n> >faster, but see my recent post to Josh Berkus --- the additional code\\n> >will be so burdensome that I doubt it would be accepted. If it was, I\\n> >bet we would have considered it long ago.\\n> >\\n> >I think the only way we are going to get sharding into Postgres is to do\\n> >it in a way that enhances existing Postgres capabilities.\\n> \\n> So that we have XL again?\\n\\nKind of. If XC/XL used FDWs I think we would try to use their code\\nfirst. The issue is that FDWs didn't exist at the time. I would say\\nour first approach might be doing XC/XL again with FDWs.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 17:53:47 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Sep 1, 2015, at 1:47 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n\\n> Admittedly, there are some problems with snapshots here: if you don't\\n> do anything special about snapshots, then what you have here will be\\n> \\\"eventually consistent\\\" behavior. But that might be suitable for some\\n> environments, such as very loosely coupled system where not all nodes\\n> are connected all the time.\\n\\nGiven that we’re discussing multi-node architectures here, you should expect that not all nodes will be connected at any time. Nodes fail, but the cluster should not.\\n\\n> And, for those environments where you do\\n> need consistent snapshots, we can imagine ways to get that behavior,\\n> like having the GTM consider the transaction uncommitted until it's\\n> been logically replicated to every node.\\n\\nAgain, you need a way to deal with nodes going down. I can envision building a cluster with twelve nodes replicated to each of three geographically-distributed data centers. Each replication/sync model needs to be able to handle nodes going up and down, data centers or racks going up or down, and nodes being added and removed.\\n\\nBut even with smaller clusters, there’s no way around the fact that no system can guarantee that all nodes will be available at all times.\\n\\nBest,\\n\\nDavid\",\n \"msg_date\": \"Tue, 1 Sep 2015 15:07:41 -0700\",\n \"msg_from\": \"\\\"David E. Wheeler\\\" <david@justatheory.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 09/01/2015 02:29 PM, Tomas Vondra wrote:\\n> Hi,\\n> \\n> On 09/01/2015 09:19 PM, Josh Berkus wrote:\\n>> Other way around, that is, having replication standbys as the only\\n>> method of redundancy requires either high data loss or high latency\\n>> for all writes.\\n> \\n> I haven't said that. I said that we should allow that topology, not that\\n> it should be the only method of redundancy.\\n\\nAh, OK, I didn't understand you. Of course I'm in favor of supporting\\nboth methods of redundancy if we can.\\n\\n>> In the case of sync rep, we are required to wait for at least double\\n>> network lag time in order to do a single write ... making\\n>> write-scalability quite difficult.\\n> \\n> Which assumes that latency (or rather the increase due to syncrep) is a\\n> problem for the use case. Which may be the case for many use cases, but\\n> certainly is not a problem for many BI/DWH use cases performing mostly\\n> large batch loads. In those cases the network bandwidth may be quite\\n> important resource.\\n\\nI'll argue that BI/DW is the least interesting use case for mainstream\\nPostgreSQL because there are production-quality forks which do this\\n(mostly propietary, but we can work on that). We really need a solution\\nwhich works for OLTP.\\n\\n> For example assume that there are just two shards in two separate data\\n> centers, connected by a link with limited bandwidth. Now, let's assume\\n> you always keep a local replica for failover. So you have A1+A2 in DC1,\\n> B1+B2 in DC2. If you're in DC1, then writing data to B1 means you also\\n> have to write data to B2 and wait for it. So either you send the data to\\n> each node separately (consuming 2x the bandwidth), or send it to B1 and\\n> let it propagate to B2 e.g. through sync rep.\\n> \\n> So while you may be right in single-DC deployments, with multi-DC\\n> deployments the situation is quite different - not only that the network\\n> bandwidth is not unlimited, but because latencies within DC may be a\\n> fraction of latencies between the locations (to the extent that the\\n> increase due to syncrep may be just noise). So the local replication may\\n> be actually way faster.\\n\\nI'm not seeing how the above is better using syncrep than using shard\\ncopying?\\n\\n> I can imagine forwarding the data between B1 and B2 even with a purely\\n> sharding solution, but at that point you effectively re-implemented\\n> syncrep.\\n\\nNot really, the mechanism is different and the behavior is different.\\nOne critical deficiency in using binary syncrep is that you can't do\\nround-robin redundancy at all; every redundant node has to be an exact\\nmirror of another node. In a good HA distributed system, you want\\nmultiple shards per node, and you want each shard to be replicated to a\\ndifferent node, so that in the event of node failure you're not dumping\\nthe full load on one other server.\\n\\n> IMHO the design has to address the multi-DC setups somehow. I think that\\n> many of the customers who are so concerned about scaling to many shards\\n> are also concerned about availability in case of DC outages, no?\\n\\nCertainly. But users located in a single DC shouldn't pay the same\\noverhead as users who are geographically spread.\\n\\n> I don't follow. With sync rep we do know whether the copy is OK or not,\\n> because the node either confirms writes or not. The failover certainly\\n> is more complicated and is not immediate (to the extent of keeping a\\n> copy at the sharding level), but it's a question of trade-offs.\\n> \\n> It's true we don't have auto-failover solution at the moment, but as I\\n> said - I can easily imagine most people using just sharding, while some\\n> deployments use syncrep with manual failover.\\n\\nAs long as direct shard copying is available, I'm happy. I have no\\ncomplaints about additional mechanisms.\\n\\nI'm bringing this up because the FDW proposal made at pgCon did not\\ninclude *any* mechanism for HA/redundancy, just some handwaving about\\nreplication and/or BDR. This was one of the critical design failures of\\nPostgresXC. A multinode system without automated node failover and\\nreplacement is a low-availability system.\\n\\n>> If we write to multiple copies as a part of the sharding feature,\\n>> then that can be parallelized, so that we are waiting only as long as\\n>> the slowest write (or in failure cases, as long as the shard\\n>> timeout). Further, we can check for shard-copy health and update\\n>> shard availability data with each user request, so that the ability\\n>> to see stale/bad data is minimized.\\n> \\n> Again, this assumes infinite network bandwidth.\\n\\nIn what way is the total network bandwitdh used in the system different\\nfor shard copying than for sync replication?\\n\\n-- \\nJosh Berkus\\nPostgreSQL Experts Inc.\\nhttp://pgexperts.com\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 15:09:09 -0700\",\n \"msg_from\": \"Josh Berkus <josh@agliodbs.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 12:40:40PM -0400, Robert Haas wrote:\\n> On Tue, Sep 1, 2015 at 6:55 AM, Bruce Momjian <bruce@momjian.us> wrote:\\n> > I assumed these queries were going to be solved by sending as digested\\n> > data as possible to the coordinator, and having the coordinator complete\\n> > any remaining processing. I think we are going to need to decide if\\n> > such \\\"sending data back to shards\\\" is something we are ever going to\\n> > implement. I can see FDWs _not_ working well for that use-case.\\n> \\n> I do think we are going to want to support that. All the people I've\\n> talked to about parallel and distributed query processing agree that\\n> you need to do that sort of thing to get really good and scalable\\n> performance. I think that we could make a lot of headway as compared\\n> with the status quo just by implementing more pushdown optimizations\\n> than we have today. Right now, SELECT COUNT(*) FROM table will suck\\n> back the whole remote table and count the rows locally, and that's\\n> stupid. We can fix that case with better pushdown logic. We can also\\n> fix the case of N-way join nests where the joins are either on the\\n> partitioning key or to replicated tables. But suppose you have a join\\n> between two tables which are sharded across the cluster but not on the\\n> partitioning key. There's no way to push the join down, so all the\\n> work comes back to the coordinator, which is possibly OK if such\\n> queries are rare, but not so hot if they are frequent.\\n\\nLet me clearer about what the Citus Data paper shows. I said originally\\nthat the data was sent to the coordinator, sorted, then resent to the\\nshards, but the document:\\n\\n\\thttps://goo.gl/vJWF85\\n\\thttps://www.citusdata.com/blog/114-how-to-build-your-distributed-database\\n\\nhas the shards create the groups and the groups are sent to the other\\nshards. For example, to do COUNT(DISTINCT) if you have three shards,\\nthen each shard breaks its data into 3 buckets (1B in size), then the\\nfirst bucket from each of the three shards goes to the first shard, and\\nthe second bucket goes to the second shared, etc.\\n\\nBasically, they are doing map-reduce, and the shards are creating\\nadditional batches that get shipped to other shards. I can see FDWs not\\nworking well in that case as you are really creating a new data layout\\njust for the query. This explains why the XC/XL people are saying they\\nwould use FDWs if they existed at the time they started development,\\nwhile the Citus Data people are saying they couldn't use FDWs as they\\ncurrently exist. They probably both needed FDW improvements, but I\\nthink the Citus Data features would need a lot more.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 18:11:45 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 10:17 AM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> On Tue, Sep 1, 2015 at 1:06 PM, Josh Berkus <josh@agliodbs.com> wrote:\\n>> You're assuming that our primary bottleneck for writes is IO. It's not\\n>> at present for most users, and it certainly won't be in the future. You\\n>> need to move your thinking on systems resources into the 21st century,\\n>> instead of solving the resource problems from 15 years ago.\\n>\\n> Your experience doesn't match mine. I find that it's frequently\\n> impossible to get the system to use all of the available CPU capacity,\\n> either because you're bottlenecked on locks or because you are\\n> bottlenecked on the I/O subsystem, and with the locking improvements\\n> in newer versions, the former is becoming less and less common.\\n\\nI think you're both right. I think that we need to fix the buffer\\nmanager, to make its caching algorithm smarter. Since we're mostly\\nusing the filesystem cache, this is particularly important for\\nPostgreSQL. We need to remember usage information for evicted blocks\\nfor some period of time afterwards. This problem is largely a problem\\nwith Postgres in particular, I suspect.\\n\\nAt the same time, I agree with Josh's assessment that long-term, we\\nare going to have the biggest problem with memory latency and memory\\nbandwidth, which are usually considered facets of CPU performance, and\\nwith internal lock contention. Addressing the memory access bottleneck\\ndovetails with parallelism, in that it must be considered alongside\\nparallelism. Josh's \\\"21st century\\\" remark seems quite justified to me.\\nFor a further example of this, check out my latest progress with\\nexternal sorting, which I plan to post later in the week. I/O isn't\\nthe big problem there at all, and I now think we can make external\\nsorts close to internal sorts in performance across the board.\\n\\nI imagine that Josh's experience is based on workloads that mostly fit\\nin shared_buffers, so I can see why you'd disagree if that was\\nsomething you've seen less of. I'll quote Hellerstein and Stonebraker\\nin 2007 [1]:\\n\\n\\\"Copying data in memory can be a serious bottleneck. Copies contribute\\nlatency, consume CPU cycles, and can flood the CPU data. This fact is\\noften a surprise to people who have not operated or implemented a\\ndatabase system, and assume that main-memory operations are “free”\\ncompared to disk I/O. But in practice, throughput in a well-tuned\\ntransaction processing DBMS is typically not I/O-bound. This is\\nachieved in high-end installations by purchasing sufficient disks and\\nRAM so that repeated page requests are absorbed by the buffer pool,\\nand disk I/Os are shared across the disk arms at a rate that can feed\\nthe data appetite of all the processors in the system.\\\"\\n\\n>> Our real future bottlenecks are:\\n>>\\n>> * ability to handle more than a few hundred connections\\n>> * locking limits on the scalability of writes\\n>> * ability to manage large RAM and data caches\\n>\\n> I do agree that all of those things are problems, FWIW.\\n\\nThese seem like our long term problems, to me.\\n\\n[1] http://db.cs.berkeley.edu/papers/fntdb07-architecture.pdf, page 213\\n-- \\nPeter Geoghegan\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 1 Sep 2015 15:15:08 -0700\",\n \"msg_from\": \"Peter Geoghegan <pg@heroku.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 2015-09-02 00:09, Josh Berkus wrote:\\n> On 09/01/2015 02:29 PM, Tomas Vondra wrote:\\n>> For example assume that there are just two shards in two separate data\\n>> centers, connected by a link with limited bandwidth. Now, let's assume\\n>> you always keep a local replica for failover. So you have A1+A2 in DC1,\\n>> B1+B2 in DC2. If you're in DC1, then writing data to B1 means you also\\n>> have to write data to B2 and wait for it. So either you send the data to\\n>> each node separately (consuming 2x the bandwidth), or send it to B1 and\\n>> let it propagate to B2 e.g. through sync rep.\\n>>\\n>> So while you may be right in single-DC deployments, with multi-DC\\n>> deployments the situation is quite different - not only that the network\\n>> bandwidth is not unlimited, but because latencies within DC may be a\\n>> fraction of latencies between the locations (to the extent that the\\n>> increase due to syncrep may be just noise). So the local replication may\\n>> be actually way faster.\\n>\\n> I'm not seeing how the above is better using syncrep than using shard\\n> copying?\\n\\nShard copying usually assumes that the origin node does the copy - the\\ndata has to go twice through the slow connection. With replication you\\ncan replicate locally over fast connection.\\n\\n>\\n>> I can imagine forwarding the data between B1 and B2 even with a purely\\n>> sharding solution, but at that point you effectively re-implemented\\n>> syncrep.\\n>\\n> Not really, the mechanism is different and the behavior is different.\\n> One critical deficiency in using binary syncrep is that you can't do\\n> round-robin redundancy at all; every redundant node has to be an exact\\n> mirror of another node. In a good HA distributed system, you want\\n> multiple shards per node, and you want each shard to be replicated to a\\n> different node, so that in the event of node failure you're not dumping\\n> the full load on one other server.\\n>\\n\\nThis assumes that we use binary replication, but we can reasonably use\\nlogical replication which can quite easily do filtering of what's\\nreplicated where.\\n\\n>> IMHO the design has to address the multi-DC setups somehow. I think that\\n>> many of the customers who are so concerned about scaling to many shards\\n>> are also concerned about availability in case of DC outages, no?\\n>\\n> Certainly. But users located in a single DC shouldn't pay the same\\n> overhead as users who are geographically spread.\\n>\\n\\nAgreed, so we should support both ways, but I don't think it's necessary\\nto support both ways in version 0.1. It's just important to not paint\\nourselves into a corner with design decisions that would make one of the\\nways impossible.\\n\\n\\n>>> If we write to multiple copies as a part of the sharding feature,\\n>>> then that can be parallelized, so that we are waiting only as long as\\n>>> the slowest write (or in failure cases, as long as the shard\\n>>> timeout). Further, we can check for shard-copy health and update\\n>>> shard availability data with each user request, so that the ability\\n>>> to see stale/bad data is minimized.\\n>>\\n>> Again, this assumes infinite network bandwidth.\\n>\\n> In what way is the total network bandwitdh used in the system different\\n> for shard copying than for sync replication?\\n>\\n\\nAgain, when shards are distributed over multiple DCs (or actually even\\nmultiple racks) the bandwidth and latency of local copy will be much\\nbetter then the one of the remote copy so the local replication can have\\nmuch lower impact on the cluster performance than remote shard copy will.\\n\\n-- \\n Petr Jelinek http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 01:14:10 +0200\",\n \"msg_from\": \"Petr Jelinek <petr@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"> On Tue, Sep 1, 2015 at 9:48 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> >\\n> > On Tue, Sep 1, 2015 at 4:15 AM, Andres Freund <andres@anarazel.de>\\nwrote:\\n> > > On 2015-08-31 20:54:51 -0400, Bruce Momjian wrote:\\n> > >> Uh, we already have a list of things we need to add to FDWs to make\\nthem\\n> > >> work, and Citus Data has provided a document of more things that are\\n> > >> needed, https://goo.gl/vJWF85. I am not sure how much bigger a red\\nflag\\n> > >> you want to confirm that everyone agrees that major FDW improvements\\nare\\n> > >> a requirement for this.\\n> > >\\n> > > Several people saying that the FDW infrastructure isn't sufficient\\nright\\n> > > now is pretty far from implying that all of them agree that the FDW\\nAPI\\n> > > is the way to go.\\n> > >\\n> > > I'm not sure myself. If it works out it's going to save us some work\\nand\\n> > > make it more realistic to get there sometime not too far off. But I'm\\n> > > afraid that the resulting system will feel like our current\\npartitioning\\n> > > implemenentation. Yes, it kinda works, but it's hard to get started,\\nit\\n> > > doesn't support too many features and you're kind afraid your\\nrelatives\\n> > > will see what you've done.\\n> >\\n> > I'm not averse to making the \\\"connect to the remote nodes\\\" part of\\n> > this solution use something other than the FDW infrastructure at some\\n> > point in time if somebody's prepared to build something better. On\\n> > the other hand, I think it's extremely clear that the FDW\\n> > infrastructure has a large amount of potential upon which we have\\n> > thoroughly failed to capitalize. Patches have already been written\\n> > for UPDATE/DELETE pushdown and for join pushdown.\\n\\nWill pushing down writes (Update/Delete) sufficient to maintain sane locking\\nbehaviour and deadlock detection that can occur during writes on multiple\\nshards? For example it could easily be the case where a single Update\\nstatement could effect multiple shards and cause deadlock due to waits\\nacross the nodes. Now unless we have some distributed lock manager or\\nsome other way to know the information of locks that happens across\\nshards, it could be difficult to detect deadlocks.\\n\\n\\nWith Regards,\\nAmit Kapila.\\nEnterpriseDB: http://www.enterprisedb.com\\n\\n> On Tue, Sep 1, 2015 at 9:48 PM, Robert Haas <robertmhaas@gmail.com> wrote:> >> > On Tue, Sep 1, 2015 at 4:15 AM, Andres Freund <andres@anarazel.de> wrote:> > > On 2015-08-31 20:54:51 -0400, Bruce Momjian wrote:> > >> Uh, we already have a list of things we need to add to FDWs to make them> > >> work, and Citus Data has provided a document of more things that are> > >> needed, https://goo.gl/vJWF85. I am not sure how much bigger a red flag> > >> you want to confirm that everyone agrees that major FDW improvements are> > >> a requirement for this.> > >> > > Several people saying that the FDW infrastructure isn't sufficient right> > > now is pretty far from implying that all of them agree that the FDW API> > > is the way to go.> > >> > > I'm not sure myself. If it works out it's going to save us some work and> > > make it more realistic to get there sometime not too far off. But I'm> > > afraid that the resulting system will feel like our current partitioning> > > implemenentation. Yes, it kinda works, but it's hard to get started, it> > > doesn't support too many features and you're kind afraid your relatives> > > will see what you've done.> >> > I'm not averse to making the \\\"connect to the remote nodes\\\" part of> > this solution use something other than the FDW infrastructure at some> > point in time if somebody's prepared to build something better. On> > the other hand, I think it's extremely clear that the FDW> > infrastructure has a large amount of potential upon which we have> > thoroughly failed to capitalize. Patches have already been written> > for UPDATE/DELETE pushdown and for join pushdown.Will pushing down writes (Update/Delete) sufficient to maintain sane lockingbehaviour and deadlock detection that can occur during writes on multipleshards? For example it could easily be the case where a single Updatestatement could effect multiple shards and cause deadlock due to waitsacross the nodes. Now unless we have some distributed lock manager orsome other way to know the information of locks that happens acrossshards, it could be difficult to detect deadlocks.With Regards,Amit Kapila.EnterpriseDB: http://www.enterprisedb.com\",\n \"msg_date\": \"Wed, 2 Sep 2015 09:58:00 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 4:25 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n>\\n>\\n> The document opens a big question --- when queries can't be processed in\\n> a traditional top/down fashion, Citus has the goal of sending groups of\\n> results up the the coordinator, reordering them, then sending them back\\n> to the shards for further processing, basically using the shards as\\n> compute engines because the shards are no longer using local data to do\\n> their computations. The two examples they give are COUNT(DISTINCT) and\\n> a join across two sharded tables (\\\"CANADA\\\").\\n>\\n> I assumed these queries were going to be solved by sending as digested\\n> data as possible to the coordinator, and having the coordinator complete\\n> any remaining processing. I think we are going to need to decide if\\n> such \\\"sending data back to shards\\\" is something we are ever going to\\n> implement. I can see FDWs _not_ working well for that use-case.\\n>\\n\\nHere one related point to think is how do we envision to handle statement\\nrequests, do we want to have centeralized coordinator which will process\\nall requests or the requests could be received by any node?\\nI think both kind of systems have their own pros and cons like if we want\\nto have centralized coordinator kind of system, then it might be limited\\nby the number of simultaneous requests it can handle and if go other way\\nlike allow requests to be processed by each individual nodes, then we\\nhave to think about replicating all meta-data on all nodes.\\n\\nI think Collecting statistics about different objects is another thing which\\ncan differ depending on the strategy we choose to allow requests.\\n\\n\\nWith Regards,\\nAmit Kapila.\\nEnterpriseDB: http://www.enterprisedb.com\\n\\nOn Tue, Sep 1, 2015 at 4:25 PM, Bruce Momjian <bruce@momjian.us> wrote:>>> The document opens a big question --- when queries can't be processed in> a traditional top/down fashion, Citus has the goal of sending groups of> results up the the coordinator, reordering them, then sending them back> to the shards for further processing, basically using the shards as> compute engines because the shards are no longer using local data to do> their computations. The two examples they give are COUNT(DISTINCT) and> a join across two sharded tables (\\\"CANADA\\\").>> I assumed these queries were going to be solved by sending as digested> data as possible to the coordinator, and having the coordinator complete> any remaining processing. I think we are going to need to decide if> such \\\"sending data back to shards\\\" is something we are ever going to> implement. I can see FDWs _not_ working well for that use-case.>Here one related point to think is how do we envision to handle statementrequests, do we want to have centeralized coordinator which will processall requests or the requests could be received by any node?I think both kind of systems have their own pros and cons like if we wantto have centralized coordinator kind of system, then it might be limitedby the number of simultaneous requests it can handle and if go other waylike allow requests to be processed by each individual nodes, then wehave to think about replicating all meta-data on all nodes.I think Collecting statistics about different objects is another thing whichcan differ depending on the strategy we choose to allow requests.With Regards,Amit Kapila.EnterpriseDB: http://www.enterprisedb.com\",\n \"msg_date\": \"Wed, 2 Sep 2015 10:07:00 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 2015-09-02 PM 01:28, Amit Kapila wrote:\\n>> On Tue, Sep 1, 2015 at 9:48 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>>>\\n>>> I'm not averse to making the \\\"connect to the remote nodes\\\" part of\\n>>> this solution use something other than the FDW infrastructure at some\\n>>> point in time if somebody's prepared to build something better. On\\n>>> the other hand, I think it's extremely clear that the FDW\\n>>> infrastructure has a large amount of potential upon which we have\\n>>> thoroughly failed to capitalize. Patches have already been written\\n>>> for UPDATE/DELETE pushdown and for join pushdown.\\n> \\n> Will pushing down writes (Update/Delete) sufficient to maintain sane locking\\n> behaviour and deadlock detection that can occur during writes on multiple\\n> shards? For example it could easily be the case where a single Update\\n> statement could effect multiple shards and cause deadlock due to waits\\n> across the nodes. Now unless we have some distributed lock manager or\\n> some other way to know the information of locks that happens across\\n> shards, it could be difficult to detect deadlocks.\\n> \\n\\nI wonder if Ashutosh's atomic foreign transactions patch would address any\\nissues inherent in such cases...\\n\\nThanks,\\nAmit\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 14:28:44 +0900\",\n \"msg_from\": \"Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 2015/09/02 14:28, Amit Langote wrote:\\n> On 2015-09-02 PM 01:28, Amit Kapila wrote:\\n>>> On Tue, Sep 1, 2015 at 9:48 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>>>> I'm not averse to making the \\\"connect to the remote nodes\\\" part of\\n>>>> this solution use something other than the FDW infrastructure at some\\n>>>> point in time if somebody's prepared to build something better. On\\n>>>> the other hand, I think it's extremely clear that the FDW\\n>>>> infrastructure has a large amount of potential upon which we have\\n>>>> thoroughly failed to capitalize. Patches have already been written\\n>>>> for UPDATE/DELETE pushdown and for join pushdown.\\n\\n>> Will pushing down writes (Update/Delete) sufficient to maintain sane locking\\n>> behaviour and deadlock detection that can occur during writes on multiple\\n>> shards? For example it could easily be the case where a single Update\\n>> statement could effect multiple shards and cause deadlock due to waits\\n>> across the nodes. Now unless we have some distributed lock manager or\\n>> some other way to know the information of locks that happens across\\n>> shards, it could be difficult to detect deadlocks.\\n\\n> I wonder if Ashutosh's atomic foreign transactions patch would address any\\n> issues inherent in such cases...\\n\\nThe UPDATE/DELETE pushdown, which I've proposed, would ensure the sane \\nbehaviour for inherited UPDATEs/DELETEs, as existing non-pushed-down \\nUPDATE/DELETE does, because inheritance_planner guarantees that all \\nbackends lock inheritance children in the same order to avoid needless \\ndeadlocks.\\n\\nBest regards,\\nEtsuro Fujita\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 02 Sep 2015 15:05:22 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 11:35 AM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\\nwrote:\\n\\n> On 2015/09/02 14:28, Amit Langote wrote:\\n>\\n>> On 2015-09-02 PM 01:28, Amit Kapila wrote:\\n>>\\n>>> On Tue, Sep 1, 2015 at 9:48 PM, Robert Haas <robertmhaas@gmail.com>\\n>>>> wrote:\\n>>>>\\n>>>>> I'm not averse to making the \\\"connect to the remote nodes\\\" part of\\n>>>>> this solution use something other than the FDW infrastructure at some\\n>>>>> point in time if somebody's prepared to build something better. On\\n>>>>> the other hand, I think it's extremely clear that the FDW\\n>>>>> infrastructure has a large amount of potential upon which we have\\n>>>>> thoroughly failed to capitalize. Patches have already been written\\n>>>>> for UPDATE/DELETE pushdown and for join pushdown.\\n>>>>>\\n>>>>\\n> Will pushing down writes (Update/Delete) sufficient to maintain sane\\n>>> locking\\n>>> behaviour and deadlock detection that can occur during writes on multiple\\n>>> shards? For example it could easily be the case where a single Update\\n>>> statement could effect multiple shards and cause deadlock due to waits\\n>>> across the nodes. Now unless we have some distributed lock manager or\\n>>> some other way to know the information of locks that happens across\\n>>> shards, it could be difficult to detect deadlocks.\\n>>>\\n>>\\n> I wonder if Ashutosh's atomic foreign transactions patch would address any\\n>> issues inherent in such cases...\\n>>\\n>\\n> The UPDATE/DELETE pushdown, which I've proposed, would ensure the sane\\n> behaviour for inherited UPDATEs/DELETEs, as existing non-pushed-down\\n> UPDATE/DELETE does, because inheritance_planner guarantees that all\\n> backends lock inheritance children in the same order to avoid needless\\n> deadlocks.\\n>\\n>\\nWill it be able to do it for row level locks, row level locking occurs\\nduring updation of a row, so will it be possible to ensure the order of\\nlocks on rows?\\n\\nWill it handle deadlocks across different table partitions. Consider\\na case as below:\\n\\nT1\\n1. Updates row R1 of T1 on shard S1\\n2. Updates row R2 of T2 on shard S2\\n\\nT2\\n1. Updates row R2 of T2 on shard S2\\n2. Updates row R1 of T1 on shard S1\\n\\n\\n\\nWith Regards,\\nAmit Kapila.\\nEnterpriseDB: http://www.enterprisedb.com\\n\\nOn Wed, Sep 2, 2015 at 11:35 AM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp> wrote:On 2015/09/02 14:28, Amit Langote wrote:\\n\\nOn 2015-09-02 PM 01:28, Amit Kapila wrote:\\n\\nOn Tue, Sep 1, 2015 at 9:48 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n\\nI'm not averse to making the \\\"connect to the remote nodes\\\" part of\\nthis solution use something other than the FDW infrastructure at some\\npoint in time if somebody's prepared to build something better. On\\nthe other hand, I think it's extremely clear that the FDW\\ninfrastructure has a large amount of potential upon which we have\\nthoroughly failed to capitalize. Patches have already been written\\nfor UPDATE/DELETE pushdown and for join pushdown.\\n\\n\\n\\nWill pushing down writes (Update/Delete) sufficient to maintain sane locking\\nbehaviour and deadlock detection that can occur during writes on multiple\\nshards? For example it could easily be the case where a single Update\\nstatement could effect multiple shards and cause deadlock due to waits\\nacross the nodes. Now unless we have some distributed lock manager or\\nsome other way to know the information of locks that happens across\\nshards, it could be difficult to detect deadlocks.\\n\\n\\n\\nI wonder if Ashutosh's atomic foreign transactions patch would address any\\nissues inherent in such cases...\\n\\n\\nThe UPDATE/DELETE pushdown, which I've proposed, would ensure the sane behaviour for inherited UPDATEs/DELETEs, as existing non-pushed-down UPDATE/DELETE does, because inheritance_planner guarantees that all backends lock inheritance children in the same order to avoid needless deadlocks.\\nWill it be able to do it for row level locks, row level locking occursduring updation of a row, so will it be possible to ensure the order oflocks on rows?Will it handle deadlocks across different table partitions. Considera case as below:T11. Updates row R1 of T1 on shard S12. Updates row R2 of T2 on shard S2T21. Updates row R2 of T2 on shard S2 2. Updates row R1 of T1 on shard S1With Regards,Amit Kapila.EnterpriseDB: http://www.enterprisedb.com\",\n \"msg_date\": \"Wed, 2 Sep 2015 11:55:38 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 2015-09-02 PM 03:25, Amit Kapila wrote:\\n> On Wed, Sep 2, 2015 at 11:35 AM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\\n>>\\n>> The UPDATE/DELETE pushdown, which I've proposed, would ensure the sane\\n>> behaviour for inherited UPDATEs/DELETEs, as existing non-pushed-down\\n>> UPDATE/DELETE does, because inheritance_planner guarantees that all\\n>> backends lock inheritance children in the same order to avoid needless\\n>> deadlocks.\\n>>\\n>>\\n> Will it be able to do it for row level locks, row level locking occurs\\n> during updation of a row, so will it be possible to ensure the order of\\n> locks on rows?\\n> \\n> Will it handle deadlocks across different table partitions. Consider\\n> a case as below:\\n> \\n> T1\\n> 1. Updates row R1 of T1 on shard S1\\n> 2. Updates row R2 of T2 on shard S2\\n> \\n> T2\\n> 1. Updates row R2 of T2 on shard S2\\n> 2. Updates row R1 of T1 on shard S1\\n> \\n\\nAs long as shards are processed in the same order in different\\ntransactions, ISTM, this issue should not arise? I can imagine it becoming\\na concern if parallel shard processing enters the scene. Am I missing\\nsomething?\\n\\nThanks,\\nAmit\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 15:40:40 +0900\",\n \"msg_from\": \"Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 2015/09/02 15:40, Amit Langote wrote:\\n> On 2015-09-02 PM 03:25, Amit Kapila wrote:\\n>> On Wed, Sep 2, 2015 at 11:35 AM, Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\\n>>> The UPDATE/DELETE pushdown, which I've proposed, would ensure the sane\\n>>> behaviour for inherited UPDATEs/DELETEs, as existing non-pushed-down\\n>>> UPDATE/DELETE does, because inheritance_planner guarantees that all\\n>>> backends lock inheritance children in the same order to avoid needless\\n>>> deadlocks.\\n\\n>> Will it be able to do it for row level locks, row level locking occurs\\n>> during updation of a row, so will it be possible to ensure the order of\\n>> locks on rows?\\n\\n>> Will it handle deadlocks across different table partitions. Consider\\n>> a case as below:\\n>>\\n>> T1\\n>> 1. Updates row R1 of T1 on shard S1\\n>> 2. Updates row R2 of T2 on shard S2\\n>>\\n>> T2\\n>> 1. Updates row R2 of T2 on shard S2\\n>> 2. Updates row R1 of T1 on shard S1\\n\\n> As long as shards are processed in the same order in different\\n> transactions, ISTM, this issue should not arise? I can imagine it becoming\\n> a concern if parallel shard processing enters the scene. Am I missing\\n> something?\\n\\nYeah, I thinks so, too.\\n\\nSorry, maybe my explanation above was not enough, but in the inherted \\nUPDATEs/DELETEs, the table modification is also ensured to be done in \\nthe same order. So, as Amit Langote said, both transactions will do the \\nupdates in the same order.\\n\\nBest regards,\\nEtsuro Fujita\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 02 Sep 2015 15:59:42 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"Amit Langote wrote:\\r\\n> On 2015-09-02 PM 03:25, Amit Kapila wrote:\\r\\n>> Will it handle deadlocks across different table partitions. Consider\\r\\n>> a case as below:\\r\\n>>\\r\\n>> T1\\r\\n>> 1. Updates row R1 of T1 on shard S1\\r\\n>> 2. Updates row R2 of T2 on shard S2\\r\\n>>\\r\\n>> T2\\r\\n>> 1. Updates row R2 of T2 on shard S2\\r\\n>> 2. Updates row R1 of T1 on shard S1\\r\\n\\r\\n> As long as shards are processed in the same order in different\\r\\n> transactions, ISTM, this issue should not arise? I can imagine it becoming\\r\\n> a concern if parallel shard processing enters the scene. Am I missing\\r\\n> something?\\r\\n\\r\\nThat would only hold for a single query, right?\\r\\n\\r\\nIf 1. and 2. in the above example come from different queries within one\\r\\ntransaction, you cannot guarantee that shards are processed in the same order.\\r\\n\\r\\nSo T1 and T2 could deadlock.\\r\\n\\r\\nYours,\\r\\nLaurenz Albe\\r\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 07:07:56 +0000\",\n \"msg_from\": \"Albe Laurenz <laurenz.albe@wien.gv.at>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 2015-09-02 PM 04:07, Albe Laurenz wrote:\\n> Amit Langote wrote:\\n>> On 2015-09-02 PM 03:25, Amit Kapila wrote:\\n>>> Will it handle deadlocks across different table partitions. Consider\\n>>> a case as below:\\n>>>\\n>>> T1\\n>>> 1. Updates row R1 of T1 on shard S1\\n>>> 2. Updates row R2 of T2 on shard S2\\n>>>\\n>>> T2\\n>>> 1. Updates row R2 of T2 on shard S2\\n>>> 2. Updates row R1 of T1 on shard S1\\n> \\n>> As long as shards are processed in the same order in different\\n>> transactions, ISTM, this issue should not arise? I can imagine it becoming\\n>> a concern if parallel shard processing enters the scene. Am I missing\\n>> something?\\n> \\n> That would only hold for a single query, right?\\n> \\n> If 1. and 2. in the above example come from different queries within one\\n> transaction, you cannot guarantee that shards are processed in the same order.\\n> \\n> So T1 and T2 could deadlock.\\n> \\n\\nSorry, I failed to see why that would be the case. Could you elaborate?\\n\\nThanks,\\nAmit\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 16:40:37 +0900\",\n \"msg_from\": \"Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 2015/09/02 16:40, Amit Langote wrote:\\n> On 2015-09-02 PM 04:07, Albe Laurenz wrote:\\n>> Amit Langote wrote:\\n>>> On 2015-09-02 PM 03:25, Amit Kapila wrote:\\n>>>> Will it handle deadlocks across different table partitions. Consider\\n>>>> a case as below:\\n>>>>\\n>>>> T1\\n>>>> 1. Updates row R1 of T1 on shard S1\\n>>>> 2. Updates row R2 of T2 on shard S2\\n>>>>\\n>>>> T2\\n>>>> 1. Updates row R2 of T2 on shard S2\\n>>>> 2. Updates row R1 of T1 on shard S1\\n>>\\n>>> As long as shards are processed in the same order in different\\n>>> transactions, ISTM, this issue should not arise? I can imagine it becoming\\n>>> a concern if parallel shard processing enters the scene. Am I missing\\n>>> something?\\n>>\\n>> That would only hold for a single query, right?\\n>>\\n>> If 1. and 2. in the above example come from different queries within one\\n>> transaction, you cannot guarantee that shards are processed in the same order.\\n>>\\n>> So T1 and T2 could deadlock.\\n\\n> Sorry, I failed to see why that would be the case. Could you elaborate?\\n\\nI think Laurenz would assume that the updates 1. and 2. in the above \\ntransactions are performed *in a non-inherited manner*. If that's \\nright, T1 and T2 could deadlock, but I think we assume here to run \\ntransactions over shards *in an inherited manner*.\\n\\nBest regards,\\nEtsuro Fujita\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 02 Sep 2015 17:07:23 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"Etsuro Fujita wrote:\\r\\n> On 2015/09/02 16:40, Amit Langote wrote:\\r\\n>> On 2015-09-02 PM 04:07, Albe Laurenz wrote:\\r\\n>>> Amit Langote wrote:\\r\\n>>>> On 2015-09-02 PM 03:25, Amit Kapila wrote:\\r\\n>>>>> Will it handle deadlocks across different table partitions. Consider\\r\\n>>>>> a case as below:\\r\\n>>>>>\\r\\n>>>>> T1\\r\\n>>>>> 1. Updates row R1 of T1 on shard S1\\r\\n>>>>> 2. Updates row R2 of T2 on shard S2\\r\\n>>>>>\\r\\n>>>>> T2\\r\\n>>>>> 1. Updates row R2 of T2 on shard S2\\r\\n>>>>> 2. Updates row R1 of T1 on shard S1\\r\\n>>>\\r\\n>>>> As long as shards are processed in the same order in different\\r\\n>>>> transactions, ISTM, this issue should not arise? I can imagine it becoming\\r\\n>>>> a concern if parallel shard processing enters the scene. Am I missing\\r\\n>>>> something?\\r\\n>>>\\r\\n>>> That would only hold for a single query, right?\\r\\n>>>\\r\\n>>> If 1. and 2. in the above example come from different queries within one\\r\\n>>> transaction, you cannot guarantee that shards are processed in the same order.\\r\\n>>>\\r\\n>>> So T1 and T2 could deadlock.\\r\\n> \\r\\n>> Sorry, I failed to see why that would be the case. Could you elaborate?\\r\\n> \\r\\n> I think Laurenz would assume that the updates 1. and 2. in the above\\r\\n> transactions are performed *in a non-inherited manner*. If that's\\r\\n> right, T1 and T2 could deadlock, but I think we assume here to run\\r\\n> transactions over shards *in an inherited manner*.\\r\\n\\r\\nYes, but does every update affect all shards?\\r\\n\\r\\nIf I say \\\"UPDATE t1 SET col = 1 WHERE id = 42\\\" and the row with id 42\\r\\nhappens to be on shard S1, the update would only affect that shard, right?\\r\\n\\r\\nNow if \\\"UPDATE t2 SET col = 1 WHERE id = 42\\\" would only take place on\\r\\nshard S2, and two transactions issue both updates in different order,\\r\\none transaction would be waiting for a lock on shard S1, while the other\\r\\nwould be waiting for a lock on shard S2, right?\\r\\n\\r\\nBut maybe I'm missing something fundamental.\\r\\n\\r\\nYours,\\r\\nLaurenz Albe\\r\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 08:58:02 +0000\",\n \"msg_from\": \"Albe Laurenz <laurenz.albe@wien.gv.at>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 2015-09-02 PM 05:07, Etsuro Fujita wrote:\\n> On 2015/09/02 16:40, Amit Langote wrote:\\n>> On 2015-09-02 PM 04:07, Albe Laurenz wrote:\\n>>>\\n>>> That would only hold for a single query, right?\\n>>>\\n>>> If 1. and 2. in the above example come from different queries within one\\n>>> transaction, you cannot guarantee that shards are processed in the same\\n>>> order.\\n>>>\\n>>> So T1 and T2 could deadlock.\\n> \\n>> Sorry, I failed to see why that would be the case. Could you elaborate?\\n> \\n> I think Laurenz would assume that the updates 1. and 2. in the above\\n> transactions are performed *in a non-inherited manner*. If that's right,\\n> T1 and T2 could deadlock, but I think we assume here to run transactions\\n> over shards *in an inherited manner*.\\n> \\n\\nI think Albe may have a point here...\\n\\nEven inherited updates case appears to cause a deadlock if they are in\\ndifferent queries. Demonstrated below:\\n\\n-- setup\\nCREATE TABLE t(a int);\\nCREATE TABLE t1() INHERITS(t);\\nCREATE TABLE t2() INHERITS(t);\\n\\nINSERT INTO t1 VALUES (1);\\nINSERT INTO t2 VALUES (2);\\n\\n-- in session 1\\nBEGIN;\\nUPDATE t SET a = a + 1 WHERE a = 1;\\n<ok>\\n\\n-- in session 2\\nBEGIN;\\nUPDATE t SET a = a + 1 WHERE a = 2;\\n<ok>\\n\\n-- back in session 1\\nUPDATE t SET a = a + 1 WHERE a = 2;\\n<waits>\\n\\n-- back in session 2\\nUPDATE t SET a = a + 1 WHERE a = 1;\\n<deadlock is detected>\\n\\n\\nThanks,\\nAmit\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 18:41:13 +0900\",\n \"msg_from\": \"Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 12:49 AM, Josh Berkus <josh@agliodbs.com> wrote:\\n\\n> On 09/01/2015 11:36 AM, Tomas Vondra wrote:\\n> >> We want multiple copies of shards created by the sharding system itself.\\n> >> Having a separate, and completely orthagonal, redundancy system to the\\n> >> sharding system is overly burdensome on the DBA and makes low-data-loss\\n> >> HA impossible.\\n> >\\n> > IMHO it'd be quite unfortunate if the design would make it impossible to\\n> > combine those two features (e.g. creating standbys for shards and\\n> > failing over to them).\\n> >\\n> > It's true that solving HA at the sharding level (by keeping multiple\\n> > copies of a each shard) may be simpler than combining sharding and\\n> > standbys, but I don't see why it makes low-data-loss HA impossible.\\n>\\n> Other way around, that is, having replication standbys as the only\\n> method of redundancy requires either high data loss or high latency for\\n> all writes.\\n>\\n> In the case of async rep, every time we fail over a node, the entire\\n> cluser would need to roll back to the last common known-good replay\\n> point, hence high data loss.\\n>\\n> In the case of sync rep, we are required to wait for at least double\\n> network lag time in order to do a single write ... making\\n> write-scalability quite difficult.\\n>\\n> Futher, if using replication the sharding system would have no way to\\n> (a) find out immediately if a copy was bad and (b) fail over quickly to\\n> a copy of the shard if the first requested copy was not responding.\\n> With async replication, we also can't use multiple copies of the same\\n> shard as a way to balance read workloads.\\n>\\n> If we write to multiple copies as a part of the sharding feature, then\\n> that can be parallelized, so that we are waiting only as long as the\\n> slowest write (or in failure cases, as long as the shard timeout).\\n> Further, we can check for shard-copy health and update shard\\n> availability data with each user request, so that the ability to see\\n> stale/bad data is minimized.\\n>\\n\\nXC (and I guess XL, pgPool II as well) did this by firing same DML\\nstatement to all the copies after resolving any volatile references (e.g.\\nnow()) in DML, so that all the copies get the same values. That method\\nhowever needed some row identifier which can identify same row on all the\\nreplicas. Primary key is used as row identifier usually, but not all use\\ncases which require shards to be replicated have primary key in their\\nsharded tables.\\n\\n\\n>\\n> There are obvious problems with multiplexing writes, which you can\\n> figure out if you knock pg_shard around a bit. But I really think that\\n> solving those problems is the only way to go.\\n>\\n> Mind you, I see a strong place for binary replication and BDR for\\n> multi-region redundancy; you really don't want that to be part of the\\n> sharding system if you're aiming for write scalability.\\n>\\n> --\\n> Josh Berkus\\n> PostgreSQL Experts Inc.\\n> http://pgexperts.com\\n>\\n>\\n> --\\n> Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\n> To make changes to your subscription:\\n> http://www.postgresql.org/mailpref/pgsql-hackers\\n>\\n\\n\\n\\n-- \\nBest Wishes,\\nAshutosh Bapat\\nEnterpriseDB Corporation\\nThe Postgres Database Company\\n\\nOn Wed, Sep 2, 2015 at 12:49 AM, Josh Berkus <josh@agliodbs.com> wrote:On 09/01/2015 11:36 AM, Tomas Vondra wrote:\\n>> We want multiple copies of shards created by the sharding system itself.\\n>> Having a separate, and completely orthagonal, redundancy system to the\\n>> sharding system is overly burdensome on the DBA and makes low-data-loss\\n>> HA impossible.\\n>\\n> IMHO it'd be quite unfortunate if the design would make it impossible to\\n> combine those two features (e.g. creating standbys for shards and\\n> failing over to them).\\n>\\n> It's true that solving HA at the sharding level (by keeping multiple\\n> copies of a each shard) may be simpler than combining sharding and\\n> standbys, but I don't see why it makes low-data-loss HA impossible.\\n\\nOther way around, that is, having replication standbys as the only\\nmethod of redundancy requires either high data loss or high latency for\\nall writes.\\n\\nIn the case of async rep, every time we fail over a node, the entire\\ncluser would need to roll back to the last common known-good replay\\npoint, hence high data loss.\\n\\nIn the case of sync rep, we are required to wait for at least double\\nnetwork lag time in order to do a single write ... making\\nwrite-scalability quite difficult.\\n\\nFuther, if using replication the sharding system would have no way to\\n(a) find out immediately if a copy was bad and (b) fail over quickly to\\na copy of the shard if the first requested copy was not responding.\\nWith async replication, we also can't use multiple copies of the same\\nshard as a way to balance read workloads.\\n\\nIf we write to multiple copies as a part of the sharding feature, then\\nthat can be parallelized, so that we are waiting only as long as the\\nslowest write (or in failure cases, as long as the shard timeout).\\nFurther, we can check for shard-copy health and update shard\\navailability data with each user request, so that the ability to see\\nstale/bad data is minimized.XC (and I guess XL, pgPool II as well) did this by firing same DML statement to all the copies after resolving any volatile references (e.g. now()) in DML, so that all the copies get the same values. That method however needed some row identifier which can identify same row on all the replicas. Primary key is used as row identifier usually, but not all use cases which require shards to be replicated have primary key in their sharded tables. \\n\\nThere are obvious problems with multiplexing writes, which you can\\nfigure out if you knock pg_shard around a bit. But I really think that\\nsolving those problems is the only way to go.\\n\\nMind you, I see a strong place for binary replication and BDR for\\nmulti-region redundancy; you really don't want that to be part of the\\nsharding system if you're aiming for write scalability.\\n\\n--\\nJosh Berkus\\nPostgreSQL Experts Inc.\\nhttp://pgexperts.com\\n\\n\\n--\\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n-- Best Wishes,Ashutosh BapatEnterpriseDB CorporationThe Postgres Database Company\",\n \"msg_date\": \"Wed, 2 Sep 2015 15:49:29 +0530\",\n \"msg_from\": \"Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 2015-09-02 PM 06:41, Amit Langote wrote:\\n> \\n> I think Albe may have a point here...\\n> \\n> Even inherited updates case appears to cause a deadlock if they are in\\n> different queries. Demonstrated below:\\n> \\n> -- setup\\n> CREATE TABLE t(a int);\\n> CREATE TABLE t1() INHERITS(t);\\n> CREATE TABLE t2() INHERITS(t);\\n> \\n> INSERT INTO t1 VALUES (1);\\n> INSERT INTO t2 VALUES (2);\\n> \\n> -- in session 1\\n> BEGIN;\\n> UPDATE t SET a = a + 1 WHERE a = 1;\\n> <ok>\\n> \\n> -- in session 2\\n> BEGIN;\\n> UPDATE t SET a = a + 1 WHERE a = 2;\\n> <ok>\\n> \\n> -- back in session 1\\n> UPDATE t SET a = a + 1 WHERE a = 2;\\n> <waits>\\n> \\n> -- back in session 2\\n> UPDATE t SET a = a + 1 WHERE a = 1;\\n> <deadlock is detected>\\n> \\n\\nWhich, I now realize, is not the worry Amit Kapila's expresses.\\n\\nThe deadlock was *indeed detected* in this case, with all the locks in the\\nsame PG instance. In a sharded environment with multiple PG instances,\\nthat becomes tricky. DLM (distributed lock manager/deadlock detector)\\nseems indeed necessary as Amit K. suspects.\\n\\nThanks,\\nAmit\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 19:25:21 +0900\",\n \"msg_from\": \"Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 3:55 PM, Amit Langote <Langote_Amit_f8@lab.ntt.co.jp>\\nwrote:\\n\\n> On 2015-09-02 PM 06:41, Amit Langote wrote:\\n> >\\n> > I think Albe may have a point here...\\n> >\\n> > Even inherited updates case appears to cause a deadlock if they are in\\n> > different queries. Demonstrated below:\\n> >\\n> > -- setup\\n> > CREATE TABLE t(a int);\\n> > CREATE TABLE t1() INHERITS(t);\\n> > CREATE TABLE t2() INHERITS(t);\\n> >\\n> > INSERT INTO t1 VALUES (1);\\n> > INSERT INTO t2 VALUES (2);\\n> >\\n> > -- in session 1\\n> > BEGIN;\\n> > UPDATE t SET a = a + 1 WHERE a = 1;\\n> > <ok>\\n> >\\n> > -- in session 2\\n> > BEGIN;\\n> > UPDATE t SET a = a + 1 WHERE a = 2;\\n> > <ok>\\n> >\\n> > -- back in session 1\\n> > UPDATE t SET a = a + 1 WHERE a = 2;\\n> > <waits>\\n> >\\n> > -- back in session 2\\n> > UPDATE t SET a = a + 1 WHERE a = 1;\\n> > <deadlock is detected>\\n> >\\n>\\n> Which, I now realize, is not the worry Amit Kapila's expresses.\\n>\\n> The deadlock was *indeed detected* in this case, with all the locks in the\\n> same PG instance. In a sharded environment with multiple PG instances,\\n> that becomes tricky. DLM (distributed lock manager/deadlock detector)\\n> seems indeed necessary as Amit K. suspects.\\n>\\n>\\nRight. XC/XL did not address this issue and they rely on statement timeouts\\nto break distributed deadlocks.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Wed, Sep 2, 2015 at 3:55 PM, Amit Langote <Langote_Amit_f8@lab.ntt.co.jp> wrote:On 2015-09-02 PM 06:41, Amit Langote wrote:\\n>\\n> I think Albe may have a point here...\\n>\\n> Even inherited updates case appears to cause a deadlock if they are in\\n> different queries. Demonstrated below:\\n>\\n> -- setup\\n> CREATE TABLE t(a int);\\n> CREATE TABLE t1() INHERITS(t);\\n> CREATE TABLE t2() INHERITS(t);\\n>\\n> INSERT INTO t1 VALUES (1);\\n> INSERT INTO t2 VALUES (2);\\n>\\n> -- in session 1\\n> BEGIN;\\n> UPDATE t SET a = a + 1 WHERE a = 1;\\n> <ok>\\n>\\n> -- in session 2\\n> BEGIN;\\n> UPDATE t SET a = a + 1 WHERE a = 2;\\n> <ok>\\n>\\n> -- back in session 1\\n> UPDATE t SET a = a + 1 WHERE a = 2;\\n> <waits>\\n>\\n> -- back in session 2\\n> UPDATE t SET a = a + 1 WHERE a = 1;\\n> <deadlock is detected>\\n>\\n\\nWhich, I now realize, is not the worry Amit Kapila's expresses.\\n\\nThe deadlock was *indeed detected* in this case, with all the locks in the\\nsame PG instance. In a sharded environment with multiple PG instances,\\nthat becomes tricky. DLM (distributed lock manager/deadlock detector)\\nseems indeed necessary as Amit K. suspects.\\nRight. XC/XL did not address this issue and they rely on statement timeouts to break distributed deadlocks.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Wed, 2 Sep 2015 16:19:07 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 4:19 PM, Pavan Deolasee <pavan.deolasee@gmail.com>\\nwrote:\\n> On Wed, Sep 2, 2015 at 3:55 PM, Amit Langote <\\nLangote_Amit_f8@lab.ntt.co.jp> wrote:\\n>>\\n>> On 2015-09-02 PM 06:41, Amit Langote wrote:\\n>>\\n>> Which, I now realize, is not the worry Amit Kapila's expresses.\\n>>\\n>> The deadlock was *indeed detected* in this case, with all the locks in\\nthe\\n>> same PG instance. In a sharded environment with multiple PG instances,\\n>> that becomes tricky. DLM (distributed lock manager/deadlock detector)\\n>> seems indeed necessary as Amit K. suspects.\\n>>\\n>\\n> Right. XC/XL did not address this issue and they rely on statement\\ntimeouts to break distributed deadlocks.\\n>\\n\\nI think that will be difficult for application to decide and then it\\nneeds to decide the same for all statements which is tricky because\\ndifferent statements could take different time. I think it is better to\\nhave solution for this problem and deadlock should be detected.\\n\\n\\nWith Regards,\\nAmit Kapila.\\nEnterpriseDB: http://www.enterprisedb.com\\n\\nOn Wed, Sep 2, 2015 at 4:19 PM, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:> On Wed, Sep 2, 2015 at 3:55 PM, Amit Langote <Langote_Amit_f8@lab.ntt.co.jp> wrote:>>>> On 2015-09-02 PM 06:41, Amit Langote wrote:>>>> Which, I now realize, is not the worry Amit Kapila's expresses.>>>> The deadlock was *indeed detected* in this case, with all the locks in the>> same PG instance. In a sharded environment with multiple PG instances,>> that becomes tricky. DLM (distributed lock manager/deadlock detector)>> seems indeed necessary as Amit K. suspects.>>>> Right. XC/XL did not address this issue and they rely on statement timeouts to break distributed deadlocks.>I think that will be difficult for application to decide and then itneeds to decide the same for all statements which is tricky becausedifferent statements could take different time. I think it is better tohave solution for this problem and deadlock should be detected.With Regards,Amit Kapila.EnterpriseDB: http://www.enterprisedb.com\",\n \"msg_date\": \"Wed, 2 Sep 2015 17:12:42 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 2015/09/02 20:42, Amit Kapila wrote:\\n> On Wed, Sep 2, 2015 at 4:19 PM, Pavan Deolasee <pavan.deolasee@gmail.com\\n> <mailto:pavan.deolasee@gmail.com>> wrote:\\n> > On Wed, Sep 2, 2015 at 3:55 PM, Amit Langote\\n> <Langote_Amit_f8@lab.ntt.co.jp <mailto:Langote_Amit_f8@lab.ntt.co.jp>>\\n> wrote:\\n> >> On 2015-09-02 PM 06:41, Amit Langote wrote:\\n> >> Which, I now realize, is not the worry Amit Kapila's expresses.\\n\\n> >> The deadlock was *indeed detected* in this case, with all the locks\\n> in the\\n> >> same PG instance. In a sharded environment with multiple PG instances,\\n> >> that becomes tricky. DLM (distributed lock manager/deadlock detector)\\n> >> seems indeed necessary as Amit K. suspects.\\n\\nAh, you are right.\\n\\n> > Right. XC/XL did not address this issue and they rely on statement\\n> timeouts to break distributed deadlocks.\\n\\n> I think that will be difficult for application to decide and then it\\n> needs to decide the same for all statements which is tricky because\\n> different statements could take different time. I think it is better to\\n> have solution for this problem and deadlock should be detected.\\n\\n+1\\n\\nBest regards,\\nEtsuro Fujita\\n\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 02 Sep 2015 21:55:04 +0900\",\n \"msg_from\": \"Etsuro Fujita <fujita.etsuro@lab.ntt.co.jp>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 06:11:45PM -0400, Bruce Momjian wrote:\\n> Let me clearer about what the Citus Data paper shows. I said originally\\n> that the data was sent to the coordinator, sorted, then resent to the\\n> shards, but the document:\\n> \\n> \\thttps://goo.gl/vJWF85\\n> \\thttps://www.citusdata.com/blog/114-how-to-build-your-distributed-database\\n> \\n> has the shards create the groups and the groups are sent to the other\\n> shards. For example, to do COUNT(DISTINCT) if you have three shards,\\n> then each shard breaks its data into 3 buckets (1B in size), then the\\n> first bucket from each of the three shards goes to the first shard, and\\n> the second bucket goes to the second shared, etc.\\n> \\n> Basically, they are doing map-reduce, and the shards are creating\\n> additional batches that get shipped to other shards. I can see FDWs not\\n> working well in that case as you are really creating a new data layout\\n> just for the query. This explains why the XC/XL people are saying they\\n> would use FDWs if they existed at the time they started development,\\n> while the Citus Data people are saying they couldn't use FDWs as they\\n> currently exist. They probably both needed FDW improvements, but I\\n> think the Citus Data features would need a lot more.\\n\\nTo expand on this, using FDWs, it means each shard would create a\\ntemporary table on the other shards and send some if its data to those\\nshards. Once a shard gets all its data from the other shards, it will\\nprocess the data and send the result to the collector.\\n\\nThat certainly seems like something FDWs would not do well. Frankly, I\\nam unclear how Citus Data was able to do this with only backend hooks.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 10:05:58 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 7:08 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n\\n> On Tue, Sep 1, 2015 at 12:00 AM, Pavan Deolasee\\n> <pavan.deolasee@gmail.com> wrote:\\n> > My worry is that if we start implementing them again from scratch, it\\n> will\\n> > take a few years before we get them in a usable state. What XC/XL lacked\\n> is\\n> > probably a Robert Haas or a Tom Lane who could look at the work and\\n> suggest\\n> > major edits. If that had happened, the quality of the product could have\\n> > been much better today. I don't mean to derate the developers who worked\\n> on\\n> > XC/XL, but there is no harm in accepting that if someone with a much\\n> better\\n> > understanding of the whole system was part of the team, that would have\\n> > positively impacted the project. Is that an angle worth exploring? Does\\n> it\\n> > make sense to commit some more resources to say XC or XL and try to\\n> improve\\n> > the quality of the product even further? To be honest, XL is in far far\\n> > better shape (haven't really tried XC in a while) and some more\\n> QA/polishing\\n> > can make it production ready much sooner.\\n>\\n> From my point of view, and EnterpriseDB's point of view, anything that\\n> doesn't go into the core PostgreSQL distribution isn't really getting\\n> us where we need to be. If there's code in XL that would be valuable\\n> to merge into core PostgreSQL, then let's do it. If the code cannot\\n> be used but there are lessons we can learn that will make what does go\\n> into core PostgreSQL better, let's learn them. However, I don't think\\n> it's serving anybody very well that we have the XC fork, and multiple\\n> forks of the XC fork, floating around out there and people are working\\n> on those instead of working on core PostgreSQL. The reality is that\\n> we don't have enough brainpower to spread it across 2 or 3 or 4 or 5\\n> different projects and have all of them be good. The reality is,\\n> also, that horizontal scalability isn't an optional feature. There\\n> was a point in time at which the PostgreSQL project's official policy\\n> on replication was that it did not belong in core. That was a bad\\n> policy; thankfully, it was reversed, and the result was Hot Standby\\n> and Streaming Replication, incredibly important technologies without\\n> which we would not be where we are today. Horizontal scalability is\\n> just as essential.\\n>\\n\\nAgree with you, Robert.\\n\\nOne lesson from XL we got is that we need testing framework for cluster, so\\nany cluster project should at least pass functional and performance\\ntesting. XL was very easy to break and I'm wondering how many corner cases\\nstill exists. We tried several other approaches and while reading the\\npapers was a fun, in practice we found many devil details, which made the\\npaper be just a paper.\\n\\n\\n\\n>\\n> --\\n> Robert Haas\\n> EnterpriseDB: http://www.enterprisedb.com\\n> The Enterprise PostgreSQL Company\\n>\\n\\nOn Tue, Sep 1, 2015 at 7:08 PM, Robert Haas <robertmhaas@gmail.com> wrote:On Tue, Sep 1, 2015 at 12:00 AM, Pavan Deolasee\\n<pavan.deolasee@gmail.com> wrote:\\n> My worry is that if we start implementing them again from scratch, it will\\n> take a few years before we get them in a usable state. What XC/XL lacked is\\n> probably a Robert Haas or a Tom Lane who could look at the work and suggest\\n> major edits. If that had happened, the quality of the product could have\\n> been much better today. I don't mean to derate the developers who worked on\\n> XC/XL, but there is no harm in accepting that if someone with a much better\\n> understanding of the whole system was part of the team, that would have\\n> positively impacted the project. Is that an angle worth exploring? Does it\\n> make sense to commit some more resources to say XC or XL and try to improve\\n> the quality of the product even further? To be honest, XL is in far far\\n> better shape (haven't really tried XC in a while) and some more QA/polishing\\n> can make it production ready much sooner.\\n\\nFrom my point of view, and EnterpriseDB's point of view, anything that\\ndoesn't go into the core PostgreSQL distribution isn't really getting\\nus where we need to be. If there's code in XL that would be valuable\\nto merge into core PostgreSQL, then let's do it. If the code cannot\\nbe used but there are lessons we can learn that will make what does go\\ninto core PostgreSQL better, let's learn them. However, I don't think\\nit's serving anybody very well that we have the XC fork, and multiple\\nforks of the XC fork, floating around out there and people are working\\non those instead of working on core PostgreSQL. The reality is that\\nwe don't have enough brainpower to spread it across 2 or 3 or 4 or 5\\ndifferent projects and have all of them be good. The reality is,\\nalso, that horizontal scalability isn't an optional feature. There\\nwas a point in time at which the PostgreSQL project's official policy\\non replication was that it did not belong in core. That was a bad\\npolicy; thankfully, it was reversed, and the result was Hot Standby\\nand Streaming Replication, incredibly important technologies without\\nwhich we would not be where we are today. Horizontal scalability is\\njust as essential.Agree with you, Robert. One lesson from XL we got is that we need testing framework for cluster, so any cluster project should at least pass functional and performance testing. XL was very easy to break and I'm wondering how many corner cases still exists. We tried several other approaches and while reading the papers was a fun, in practice we found many devil details, which made the paper be just a paper. \\n\\n--\\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\",\n \"msg_date\": \"Wed, 2 Sep 2015 18:34:23 +0300\",\n \"msg_from\": \"Oleg Bartunov <obartunov@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 09/01/2015 04:14 PM, Petr Jelinek wrote:\\n> On 2015-09-02 00:09, Josh Berkus wrote:\\n>> On 09/01/2015 02:29 PM, Tomas Vondra wrote:\\n>>> So while you may be right in single-DC deployments, with multi-DC\\n>>> deployments the situation is quite different - not only that the network\\n>>> bandwidth is not unlimited, but because latencies within DC may be a\\n>>> fraction of latencies between the locations (to the extent that the\\n>>> increase due to syncrep may be just noise). So the local replication may\\n>>> be actually way faster.\\n>>\\n>> I'm not seeing how the above is better using syncrep than using shard\\n>> copying?\\n> \\n> Shard copying usually assumes that the origin node does the copy - the\\n> data has to go twice through the slow connection. With replication you\\n> can replicate locally over fast connection.\\n\\nAh, I was thinking of the case of having a single set of copies in the\\nremote DC, but of course that isn't going to be the case with a highly\\nredundant setup.\\n\\nBasically this seems to be saying that, in an ideal setup, we'd have\\nsome kind of synchronous per-shard replication. We don't have that at\\npresent (sync rep is whole-node, and BDR is asynchronous). There's also\\nthe question of how to deal with failures and taking bad nodes out of\\ncirculation in such a setup, especially considering that the writes\\ncould be coming from multiple other nodes.\\n\\n>> Not really, the mechanism is different and the behavior is different.\\n>> One critical deficiency in using binary syncrep is that you can't do\\n>> round-robin redundancy at all; every redundant node has to be an exact\\n>> mirror of another node. In a good HA distributed system, you want\\n>> multiple shards per node, and you want each shard to be replicated to a\\n>> different node, so that in the event of node failure you're not dumping\\n>> the full load on one other server.\\n>>\\n> \\n> This assumes that we use binary replication, but we can reasonably use\\n> logical replication which can quite easily do filtering of what's\\n> replicated where.\\n\\nIs there a way to do logical synchronous replication? I didn't think\\nthere was.\\n\\n>>> IMHO the design has to address the multi-DC setups somehow. I think that\\n>>> many of the customers who are so concerned about scaling to many shards\\n>>> are also concerned about availability in case of DC outages, no?\\n>>\\n>> Certainly. But users located in a single DC shouldn't pay the same\\n>> overhead as users who are geographically spread.\\n>>\\n> \\n> Agreed, so we should support both ways, but I don't think it's necessary\\n> to support both ways in version 0.1. It's just important to not paint\\n> ourselves into a corner with design decisions that would make one of the\\n> ways impossible.\\n\\nExactly!\\n\\nLet me explain why I'm so vocal on this point. PostgresXC didn't deal\\nwith the redundancy/node replacement at all until after version 1.0.\\nThen, when they tried to address it, they discovered that the code was\\nchock full of assumptions that \\\"1 node == 1 shard\\\", and breaking that\\nassumption would require a total refactor of the code (which never\\nhappened). I don't want to see a repeat of that mistake.\\n\\nEven if it's only on paper, any new sharding design needs to address\\nthese questions:\\n\\n1. How do we ensure no/minimal data is lost if we lose a node?\\n2. How do we replace a lost node (without taking the cluster down)?\\n 2. a. how do we allow an out-of-sync node to \\\"catch up\\\"?\\n3. How do we maintain metadata about good/bad nodes (and shard locations)?\\n4. How do we add nodes to expand the cluster?\\n\\nThere doesn't need to be code for all of the above from version 0.1, but\\nthere needs to be a plan to tackle those problems. Otherwise, we'll\\njust end up with another dead-end, not-useful-in-production technology.\\n\\n-- \\nJosh Berkus\\nPostgreSQL Experts Inc.\\nhttp://pgexperts.com\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 10:57:30 -0700\",\n \"msg_from\": \"Josh Berkus <josh@agliodbs.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 1, 2015 at 11:18 AM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> It would be a bad idea to cling blindly to the FDW infrastructure if\\n> it's fundamentally inadequate to do what we want. On the other hand,\\n> it would also be a bad idea to set about recreating it without a\\n> really good reason, and - just to take one example - the fact that it\\n> doesn't currently push down DML operations to the remote side is not a\\n> really good reason to rewrite the whole thing. On the contrary, it's\\n> a reason to put some energy into the already-written patch which\\n> implements that optimization.\\n\\nThe problem with FDW for these purposes as I see it is that too much\\nintelligence is relegated to the implementer of the API. There needs\\nto be a mechanism so that the planner can rewrite the remote query and\\nthen do some after the fact processing. This exactly what citus does;\\nif you send out AVG(foo) it rewrites that to SUM(foo) and COUNT(foo)\\nso that aggregation can be properly weighted to the result. To do\\nthis (distributed OLAP-type processing) right, the planner needs to\\n*know* that this table is in fact distributed and also know that it\\ncan make SQL compatible adjustments to the query.\\n\\nThis strikes me as a bit of a conflict of interest with FDW which\\nseems to want to hide the fact that it's foreign; the FDW\\nimplementation makes it's own optimization decisions which might make\\nsense for single table queries but breaks down in the face of joins.\\n\\nmerlin\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 12:59:55 -0500\",\n \"msg_from\": \"Merlin Moncure <mmoncure@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 1:59 PM, Merlin Moncure <mmoncure@gmail.com> wrote:\\n> On Tue, Sep 1, 2015 at 11:18 AM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>> It would be a bad idea to cling blindly to the FDW infrastructure if\\n>> it's fundamentally inadequate to do what we want. On the other hand,\\n>> it would also be a bad idea to set about recreating it without a\\n>> really good reason, and - just to take one example - the fact that it\\n>> doesn't currently push down DML operations to the remote side is not a\\n>> really good reason to rewrite the whole thing. On the contrary, it's\\n>> a reason to put some energy into the already-written patch which\\n>> implements that optimization.\\n>\\n> The problem with FDW for these purposes as I see it is that too much\\n> intelligence is relegated to the implementer of the API. There needs\\n> to be a mechanism so that the planner can rewrite the remote query and\\n> then do some after the fact processing. This exactly what citus does;\\n> if you send out AVG(foo) it rewrites that to SUM(foo) and COUNT(foo)\\n> so that aggregation can be properly weighted to the result. To do\\n> this (distributed OLAP-type processing) right, the planner needs to\\n> *know* that this table is in fact distributed and also know that it\\n> can make SQL compatible adjustments to the query.\\n>\\n> This strikes me as a bit of a conflict of interest with FDW which\\n> seems to want to hide the fact that it's foreign; the FDW\\n> implementation makes it's own optimization decisions which might make\\n> sense for single table queries but breaks down in the face of joins.\\n\\nWell, I don't think that ALL of the logic should go into the FDW. In\\nparticular, in this example, parallel aggregate needs the same query\\nrewrite, so the logic for that should live in core so that both\\nparallel and distributed queries get the benefit.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 14:27:03 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 1:57 PM, Josh Berkus <josh@agliodbs.com> wrote:\\n> Even if it's only on paper, any new sharding design needs to address\\n> these questions:\\n>\\n> 1. How do we ensure no/minimal data is lost if we lose a node?\\n> 2. How do we replace a lost node (without taking the cluster down)?\\n> 2. a. how do we allow an out-of-sync node to \\\"catch up\\\"?\\n> 3. How do we maintain metadata about good/bad nodes (and shard locations)?\\n> 4. How do we add nodes to expand the cluster?\\n>\\n> There doesn't need to be code for all of the above from version 0.1, but\\n> there needs to be a plan to tackle those problems. Otherwise, we'll\\n> just end up with another dead-end, not-useful-in-production technology.\\n\\nThis is a good point, and I think I agree with it. Let me make a few\\nobservations:\\n\\n1. None of this stuff matters very much when the data is strictly\\nread-only. You don't lose any data because you made enough copies at\\nsome point in the distant past to ensure that you wouldn't. You\\nreplace a lost node by taking anew copy. Nodes never need to catch up\\nbecause there are no changes happening. To make bring up a new node,\\nyou make a copy of an existing node (which doesn't change in the\\nmeantime). So most of these concerns are about how to handle writes.\\n\\n2. None of this stuff matters when you only have one copy of the data.\\nYour system is low-availability, but you just don't care for whatever\\nreason. The issue arises when you have multiple copies of the data,\\nand the data is being changed. Now, you have to worry about the\\ncopies getting out of sync with each other, especially when failures\\nhappen.\\n\\n3. IIUC, Postgres-XC handles this problem by reducing at least\\nvolatile functions, maybe all functions, to constants. Then it\\ngenerates an SQL statement to be sent to the data node to make the\\nappropriate change. If there's more than one copy of the data, we\\nsend a separate copy of the SQL statement to every node. I'm not sure\\nexactly what happens if some of those nodes are not available, but I\\ndon't think it's anything good. Fundamentally, this model doesn't\\nallow for many good options in that case.\\n\\n4. Therefore, I think that we should instead use logical replication,\\nwhich might be either synchronous or asynchronous. When you modify\\none copy of the data, that change will then be replicated to all other\\nnodes. If you are OK with eventual consistency, this replication can\\nbe asynchronous, and nodes that are off-line will catch up when they\\nare on-line. If you are not OK with that, then you must replicate\\nsynchronously to every node before transaction commit; or at least you\\nmust replicate synchronously to every node that is currently on-line.\\nThis presents some challenges: logical decoding currently can't\\nreplicate transactions that are still in process - replication starts\\nwhen the transaction commits. Also, we don't have any way for\\nsynchronous replication to wait for multiple nodes. But in theory\\nthose seem like limitations that can be lifted. Also, the GTM needs\\nto be aware that this stuff is happening, or it will DTWT. That too\\nseems like a problem that can be solved.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 14:41:46 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 09/02/2015 11:41 AM, Robert Haas wrote:\\n> On Wed, Sep 2, 2015 at 1:57 PM, Josh Berkus <josh@agliodbs.com> wrote:\\n>> Even if it's only on paper, any new sharding design needs to address\\n>> these questions:\\n>>\\n>> 1. How do we ensure no/minimal data is lost if we lose a node?\\n>> 2. How do we replace a lost node (without taking the cluster down)?\\n>> 2. a. how do we allow an out-of-sync node to \\\"catch up\\\"?\\n>> 3. How do we maintain metadata about good/bad nodes (and shard locations)?\\n>> 4. How do we add nodes to expand the cluster?\\n>>\\n>> There doesn't need to be code for all of the above from version 0.1, but\\n>> there needs to be a plan to tackle those problems. Otherwise, we'll\\n>> just end up with another dead-end, not-useful-in-production technology.\\n> \\n> This is a good point, and I think I agree with it. Let me make a few\\n> observations:\\n> \\n> 1. None of this stuff matters very much when the data is strictly\\n> read-only. \\n\\nYep.\\n\\n> 2. None of this stuff matters when you only have one copy of the data.\\n> Your system is low-availability, but you just don't care for whatever\\n> reason. \\n\\nUh-huh.\\n\\n> 3. IIUC, Postgres-XC handles this problem by reducing at least\\n> volatile functions, maybe all functions, to constants. Then it\\n> generates an SQL statement to be sent to the data node to make the\\n> appropriate change. If there's more than one copy of the data, we\\n> send a separate copy of the SQL statement to every node. I'm not sure\\n> exactly what happens if some of those nodes are not available, but I\\n> don't think it's anything good. Fundamentally, this model doesn't\\n> allow for many good options in that case.\\n\\npg_shard also sends the data to each node, and automatically notices\\nwhich nodes are not responding and takes them out of availability.\\nThere isn't a \\\"catch up\\\" feature yet (AFAIK), or any attempt to reduce\\nvolatile functions.\\n\\nFor that matter, last I worked on it Greenplum also did multiplexing via\\nthe writing node (or via the data loader). So this is a popular\\napproach; it has a number of drawbacks, though, of which volatile\\nfunctions are a major one.\\n\\n> 4. Therefore, I think that we should instead use logical replication,\\n> which might be either synchronous or asynchronous. When you modify\\n> one copy of the data, that change will then be replicated to all other\\n> nodes. If you are OK with eventual consistency, this replication can\\n> be asynchronous, and nodes that are off-line will catch up when they\\n> are on-line. If you are not OK with that, then you must replicate\\n> synchronously to every node before transaction commit; or at least you\\n> must replicate synchronously to every node that is currently on-line.\\n> This presents some challenges: logical decoding currently can't\\n> replicate transactions that are still in process - replication starts\\n> when the transaction commits. Also, we don't have any way for\\n> synchronous replication to wait for multiple nodes. \\n\\nWell, there is a WIP patch for that, which IMHO would be much improved\\nby having a concrete use-case like this one. What nobody is working on\\n-- and we've vetoed in the past -- is a way of automatically failing and\\nremoving from replication any node which repeatedly fails to sync, which\\nwould be a requirement for this model.\\n\\nYou'd also need a way to let the connection nodes know when a replica\\nhas fallen behind so that they can be taken out of\\nload-balancing/sharding for read queries. For the synchronous model,\\nthat would be \\\"fallen behind at all\\\"; for asynchronous it would be\\n\\\"fallen more than ### behind\\\".\\n\\n> But in theory\\n> those seem like limitations that can be lifted. Also, the GTM needs\\n> to be aware that this stuff is happening, or it will DTWT. That too\\n> seems like a problem that can be solved.\\n\\nYeah? I'd assume that a GTM would be antithetical to two-stage copying.\\n I'm not a big fan of a GTM at all, frankly; it makes clusters much\\nharder to set up, and becomes a SPOF.\\n\\n-- \\nJosh Berkus\\nPostgreSQL Experts Inc.\\nhttp://pgexperts.com\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 12:03:36 -0700\",\n \"msg_from\": \"Josh Berkus <josh@agliodbs.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 3:03 PM, Josh Berkus <josh@agliodbs.com> wrote:\\n>> 4. Therefore, I think that we should instead use logical replication,\\n>> which might be either synchronous or asynchronous. When you modify\\n>> one copy of the data, that change will then be replicated to all other\\n>> nodes. If you are OK with eventual consistency, this replication can\\n>> be asynchronous, and nodes that are off-line will catch up when they\\n>> are on-line. If you are not OK with that, then you must replicate\\n>> synchronously to every node before transaction commit; or at least you\\n>> must replicate synchronously to every node that is currently on-line.\\n>> This presents some challenges: logical decoding currently can't\\n>> replicate transactions that are still in process - replication starts\\n>> when the transaction commits. Also, we don't have any way for\\n>> synchronous replication to wait for multiple nodes.\\n>\\n> Well, there is a WIP patch for that, which IMHO would be much improved\\n> by having a concrete use-case like this one. What nobody is working on\\n> -- and we've vetoed in the past -- is a way of automatically failing and\\n> removing from replication any node which repeatedly fails to sync, which\\n> would be a requirement for this model.\\n\\nYep. It's clear to me we need that in general, not just for sharding.\\nTo me, the key is to make sure there's a way for the cluster-ware to\\nknow about the state transitions. Currently, when the synchronous\\nstandby changes, PostgreSQL doesn't tell anyone. That's a problem.\\n\\n> You'd also need a way to let the connection nodes know when a replica\\n> has fallen behind so that they can be taken out of\\n> load-balancing/sharding for read queries. For the synchronous model,\\n> that would be \\\"fallen behind at all\\\"; for asynchronous it would be\\n> \\\"fallen more than ### behind\\\".\\n\\nHow is that different from the previous thing? Just that we'd treat\\n\\\"lagging\\\" as \\\"down\\\" beyond some threshold? That doesn't seem like a\\nmandatory feature.\\n\\n>> But in theory\\n>> those seem like limitations that can be lifted. Also, the GTM needs\\n>> to be aware that this stuff is happening, or it will DTWT. That too\\n>> seems like a problem that can be solved.\\n>\\n> Yeah? I'd assume that a GTM would be antithetical to two-stage copying.\\n\\nI don't think so. If transaction A writes data on X which is\\nreplicated to Y and then commits, a new snapshot which shows A as\\ncommitted can't be used on Y until A's changes have been replicated\\nthere. That could be enforced by having the commit of A wait for\\nreplication, or by having an attempt by a later transaction to use the\\nsnapshot on Y wait until replication completes, or some even more\\nsophisticated strategy that considers whether the replication backlog\\ntouches the same data that the new transaction will read. It's\\ncomplicated, but it doesn't seem intractable.\\n\\n> I'm not a big fan of a GTM at all, frankly; it makes clusters much\\n> harder to set up, and becomes a SPOF.\\n\\nI partially agree. I think it's very important that the GTM is an\\noptional feature of whatever we end up with, rather than an\\nindispensable component. People who don't want it shouldn't have to\\npay the price in performance and administrative complexity. But at\\nthe same time, I think a lot of people will want it, because without\\nit, the fact that sharding is in use is much less transparent to the\\napplication.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 15:30:14 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"\\n\\nOn 09/02/2015 08:27 PM, Robert Haas wrote:\\n> On Wed, Sep 2, 2015 at 1:59 PM, Merlin Moncure <mmoncure@gmail.com>\\n> wrote:\\n>>\\n>> This strikes me as a bit of a conflict of interest with FDW which\\n>> seems to want to hide the fact that it's foreign; the FDW\\n>> implementation makes it's own optimization decisions which might\\n>> make sense for single table queries but breaks down in the face of\\n>> joins.\\n\\n+1 to these concerns\\n\\n> Well, I don't think that ALL of the logic should go into the FDW.\\n\\nThen maybe we shouldn't call this \\\"FDW-based sharding\\\" (or \\\"FDW \\napproach\\\" or whatever was used in this thread so far) because that kinda \\nimplies that the proposal is to build on FDW.\\n\\nIn my mind, FDW is a wonderful tool to integrate PostgreSQL with \\nexternal data sources, and it's nicely shaped for this purpose, which \\nimplies the abstractions and assumptions in the code.\\n\\nThe truth however is that many current uses of the FDW API are actually \\nusing it for different purposes because there's no other way to do that, \\nnot because FDWs are the \\\"right way\\\". And this includes the attempts to \\nbuild sharding on FDW, I think.\\n\\nSituations like this result in \\\"improvements\\\" of the API that seem to \\nimprove the API for the second group, but make the life harder for the \\noriginal FDW API audience by making the API needlessly complex. And I \\nsay \\\"seem to improve\\\" because the second group eventually runs into the \\nfundamental abstractions and assumptions the API is based on anyway.\\n\\nAnd based on the discussions at pgcon, I think this is the main reason \\nwhy people cringe when they hear \\\"FDW\\\" and \\\"sharding\\\" in the same sentence.\\n\\nI'm not opposed to reusing the FDW infrastructure, of course.\\n\\n > In particular, in this example, parallel aggregate needs the same\\n > query rewrite, so the logic for that should live in core so that\\n > both parallel and distributed queries get the benefit.\\n\\nI'm not sure the parallel query is a great example here - maybe I'm \\nwrong but I think it's a fairly isolated piece of code, and we have \\npretty clear idea of the two use cases.\\n\\nI'm sure it's non-trivial to design it well for both cases, but I think \\nthe questions for FWD/sharding will be much more about abstract concepts \\nthan particular technical solutions.\\n\\nregards\\n\\n--\\nTomas Vondra http://www.2ndQuadrant.com\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 02 Sep 2015 22:11:07 +0200\",\n \"msg_from\": \"Tomas Vondra <tomas.vondra@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 09/02/2015 12:30 PM, Robert Haas wrote:\\n> On Wed, Sep 2, 2015 at 3:03 PM, Josh Berkus <josh@agliodbs.com> wrote:\\n>>> 4. Therefore, I think that we should instead use logical replication,\\n>>> which might be either synchronous or asynchronous. When you modify\\n>>> one copy of the data, that change will then be replicated to all other\\n>>> nodes. If you are OK with eventual consistency, this replication can\\n>>> be asynchronous, and nodes that are off-line will catch up when they\\n>>> are on-line. If you are not OK with that, then you must replicate\\n>>> synchronously to every node before transaction commit; or at least you\\n>>> must replicate synchronously to every node that is currently on-line.\\n>>> This presents some challenges: logical decoding currently can't\\n>>> replicate transactions that are still in process - replication starts\\n>>> when the transaction commits. Also, we don't have any way for\\n>>> synchronous replication to wait for multiple nodes.\\n>>\\n>> Well, there is a WIP patch for that, which IMHO would be much improved\\n>> by having a concrete use-case like this one. What nobody is working on\\n>> -- and we've vetoed in the past -- is a way of automatically failing and\\n>> removing from replication any node which repeatedly fails to sync, which\\n>> would be a requirement for this model.\\n> \\n> Yep. It's clear to me we need that in general, not just for sharding.\\n> To me, the key is to make sure there's a way for the cluster-ware to\\n> know about the state transitions. Currently, when the synchronous\\n> standby changes, PostgreSQL doesn't tell anyone. That's a problem.\\n\\nThere are many parts of our replication which are still effectively\\nunmonitorable. For example, there's still no way to tell from the\\nreplica that it's lost contact with the master except by tailing the\\nlog. If we try to build bigger systems on top of these components,\\nwe'll find that we need to add a lot of instrumentation.\\n\\n> \\n>> You'd also need a way to let the connection nodes know when a replica\\n>> has fallen behind so that they can be taken out of\\n>> load-balancing/sharding for read queries. For the synchronous model,\\n>> that would be \\\"fallen behind at all\\\"; for asynchronous it would be\\n>> \\\"fallen more than ### behind\\\".\\n> \\n> How is that different from the previous thing? Just that we'd treat\\n> \\\"lagging\\\" as \\\"down\\\" beyond some threshold? That doesn't seem like a\\n> mandatory feature.\\n\\nIt's a mandatory feature if you want to load-balance reads. We have to\\nknow which nodes not to send reads to because they are out of sync.\\n\\n>> Yeah? I'd assume that a GTM would be antithetical to two-stage copying.\\n> \\n> I don't think so. If transaction A writes data on X which is\\n> replicated to Y and then commits, a new snapshot which shows A as\\n> committed can't be used on Y until A's changes have been replicated\\n> there. That could be enforced by having the commit of A wait for\\n> replication, or by having an attempt by a later transaction to use the\\n> snapshot on Y wait until replication completes, or some even more\\n> sophisticated strategy that considers whether the replication backlog\\n> touches the same data that the new transaction will read. It's\\n> complicated, but it doesn't seem intractable.\\n\\nI need to see this on a chalkboard to understand it.\\n\\n>> I'm not a big fan of a GTM at all, frankly; it makes clusters much\\n>> harder to set up, and becomes a SPOF.\\n> \\n> I partially agree. I think it's very important that the GTM is an\\n> optional feature of whatever we end up with, rather than an\\n> indispensable component. People who don't want it shouldn't have to\\n> pay the price in performance and administrative complexity. But at\\n> the same time, I think a lot of people will want it, because without\\n> it, the fact that sharding is in use is much less transparent to the\\n> application.\\n\\nIf it can be optional, then we're pretty close to covering most use\\ncases with one general infrastructure. That would be nice.\\n\\n-- \\nJosh Berkus\\nPostgreSQL Experts Inc.\\nhttp://pgexperts.com\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 14:36:30 -0700\",\n \"msg_from\": \"Josh Berkus <josh@agliodbs.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 02:41:46PM -0400, Robert Haas wrote:\\n> 4. Therefore, I think that we should instead use logical replication,\\n> which might be either synchronous or asynchronous. When you modify\\n> one copy of the data, that change will then be replicated to all other\\n> nodes. If you are OK with eventual consistency, this replication can\\n> be asynchronous, and nodes that are off-line will catch up when they\\n> are on-line. If you are not OK with that, then you must replicate\\n> synchronously to every node before transaction commit; or at least you\\n> must replicate synchronously to every node that is currently on-line.\\n> This presents some challenges: logical decoding currently can't\\n> replicate transactions that are still in process - replication starts\\n> when the transaction commits. Also, we don't have any way for\\n> synchronous replication to wait for multiple nodes. But in theory\\n> those seem like limitations that can be lifted. Also, the GTM needs\\n> to be aware that this stuff is happening, or it will DTWT. That too\\n> seems like a problem that can be solved.\\n\\nCan you explain why logical replication is better than binary\\nreplication for this use-case?\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 18:56:29 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 12:03:36PM -0700, Josh Berkus wrote:\\n> Well, there is a WIP patch for that, which IMHO would be much improved\\n> by having a concrete use-case like this one. What nobody is working on\\n> -- and we've vetoed in the past -- is a way of automatically failing and\\n> removing from replication any node which repeatedly fails to sync, which\\n> would be a requirement for this model.\\n> \\n> You'd also need a way to let the connection nodes know when a replica\\n> has fallen behind so that they can be taken out of\\n> load-balancing/sharding for read queries. For the synchronous model,\\n> that would be \\\"fallen behind at all\\\"; for asynchronous it would be\\n> \\\"fallen more than ### behind\\\".\\n\\nI think this gets back to the idea of running an administrative alert\\ncommand when we switch to using a different server for\\nsynchronous_standby_names. We can't just keep requiring external\\ntooling to identify things that the database knows easily and can send\\nan alert. Removing failed nodes is also something we should do and\\nnotify users about.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 19:14:43 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 6:56 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n> On Wed, Sep 2, 2015 at 02:41:46PM -0400, Robert Haas wrote:\\n>> 4. Therefore, I think that we should instead use logical replication,\\n>> which might be either synchronous or asynchronous. When you modify\\n>> one copy of the data, that change will then be replicated to all other\\n>> nodes. If you are OK with eventual consistency, this replication can\\n>> be asynchronous, and nodes that are off-line will catch up when they\\n>> are on-line. If you are not OK with that, then you must replicate\\n>> synchronously to every node before transaction commit; or at least you\\n>> must replicate synchronously to every node that is currently on-line.\\n>> This presents some challenges: logical decoding currently can't\\n>> replicate transactions that are still in process - replication starts\\n>> when the transaction commits. Also, we don't have any way for\\n>> synchronous replication to wait for multiple nodes. But in theory\\n>> those seem like limitations that can be lifted. Also, the GTM needs\\n>> to be aware that this stuff is happening, or it will DTWT. That too\\n>> seems like a problem that can be solved.\\n>\\n> Can you explain why logical replication is better than binary\\n> replication for this use-case?\\n\\nUh, well, for the same reasons it is better in many other cases.\\nParticularly, you probably don't want to replicate all the data on\\nmachine A to machine B, just some of it.\\n\\nTypically, sharding solutions store multiple copies of each piece of\\ndata. So let's say you have 4 machines. You divide the data into 12\\nchunks. Each machine is the write-master for 2 of those chunks, but\\nhas secondary copies of 3 others. So maybe things start out like\\nthis:\\n\\nmachine #1: master for chunks 1, 2, 3; also has copies of chunks 4, 7, 10\\nmachine #2: master for chunks 4, 5, 6; also has copies of chunks 1, 8, 11\\nmachine #3: master for chunks 7, 8, 9; also has copies of chunks 2, 5, 12\\nmachine #4: master for chunks 10, 11, 12; also has copies of chunks 3, 6, 9\\n\\nIf machine #1 is run over by a rabid triceratops, you can make machine\\n#2 the master for chunk 1, machine #3 the master for chunk 2, and\\nmachine #4 the master for chunk 3. The write load therefore remains\\nevenly divided. If you can only copy entire machines, you can't\\nachieve that in this situation.\\n\\nI'm not saying that the above is exactly what we're going to end up\\nwith, or even necessarily close. But a big part of the point of\\nsharding is that not all the machines have the same data - otherwise\\nyou are not write scaling. But it will frequently be the case, for\\nvarious reasons, that they have *overlapping* sets of data. Logical\\nreplication can handle that; physical replication can't.\\n\\nIn Postgres-XC, all tables are either sharded (part of the table is\\npresent on each node) or distributed (all of the table is present on\\nevery node). Clearly, there's no way to use physical replication in\\nthat scenario except if you are OK with having two copies of every\\nnode. But that's not a very good solution.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 21:03:25 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 3, 2015 at 3:41 AM, Robert Haas wrote:\\n> 3. IIUC, Postgres-XC handles this problem by reducing at least\\n> volatile functions, maybe all functions, to constants. Then it\\n> generates an SQL statement to be sent to the data node to make the\\n> appropriate change. If there's more than one copy of the data, we\\n> send a separate copy of the SQL statement to every node. I'm not sure\\n> exactly what happens if some of those nodes are not available, but I\\n> don't think it's anything good. Fundamentally, this model doesn't\\n> allow for many good options in that case.\\n\\nI don't recall that. Immutable functions are switched to constants in\\nthe query sent to datanodes. Volatile and stable functions are\\nevaluated locally after fetching the results from the remote node. Not\\nthat efficient for warehouse loads. My 2c.\\n\\n> 4. Therefore, I think that we should instead use logical replication,\\n> which might be either synchronous or asynchronous. When you modify\\n> one copy of the data, that change will then be replicated to all other\\n> nodes. If you are OK with eventual consistency, this replication can\\n> be asynchronous, and nodes that are off-line will catch up when they\\n> are on-line. If you are not OK with that, then you must replicate\\n> synchronously to every node before transaction commit; or at least you\\n> must replicate synchronously to every node that is currently on-line.\\n> This presents some challenges: logical decoding currently can't\\n> replicate transactions that are still in process - replication starts\\n> when the transaction commits. Also, we don't have any way for\\n> synchronous replication to wait for multiple nodes.\\n\\nThat's something that the quorum synchronous patch would address.\\nStill, having the possibility to be synchronous across multiple nodes\\ndoes not seem like to be something at the top of the list.\\n\\n> Also, the GTM needs to be aware that this stuff is happening, or it will DTWT. That too seems like a problem that can be solved.\\n\\nIf I understood correctly, yes it is with its centralized transaction\\nfacility each node is aware of the transaction status via the global\\nsnapshot.\\n-- \\nMichael\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 3 Sep 2015 11:26:11 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 09/02/2015 03:56 PM, Bruce Momjian wrote:\\n> On Wed, Sep 2, 2015 at 02:41:46PM -0400, Robert Haas wrote:\\n>> 4. Therefore, I think that we should instead use logical replication,\\n>> which might be either synchronous or asynchronous. When you modify\\n>> one copy of the data, that change will then be replicated to all other\\n>> nodes. If you are OK with eventual consistency, this replication can\\n>> be asynchronous, and nodes that are off-line will catch up when they\\n>> are on-line. If you are not OK with that, then you must replicate\\n>> synchronously to every node before transaction commit; or at least you\\n>> must replicate synchronously to every node that is currently on-line.\\n>> This presents some challenges: logical decoding currently can't\\n>> replicate transactions that are still in process - replication starts\\n>> when the transaction commits. Also, we don't have any way for\\n>> synchronous replication to wait for multiple nodes. But in theory\\n>> those seem like limitations that can be lifted. Also, the GTM needs\\n>> to be aware that this stuff is happening, or it will DTWT. That too\\n>> seems like a problem that can be solved.\\n>\\n> Can you explain why logical replication is better than binary\\n> replication for this use-case?\\n>\\n\\nSelectivity?\\n\\nJD\\n\\n\\n-- \\nCommand Prompt, Inc. - http://www.commandprompt.com/ 503-667-4564\\nPostgreSQL Centered full stack support, consulting and development.\\nAnnouncing \\\"I'm offended\\\" is basically telling the world you can't\\ncontrol your own emotions, so everyone else should do it for you.\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 19:50:25 -0700\",\n \"msg_from\": \"\\\"Joshua D. Drake\\\" <jd@commandprompt.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 07:50:25PM -0700, Joshua Drake wrote:\\n> >Can you explain why logical replication is better than binary\\n> >replication for this use-case?\\n> >\\n> \\n> Selectivity?\\n\\nI was assuming you would just create identical slaves to handle failure,\\nrather than moving selected data around.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 22:58:26 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 09:03:25PM -0400, Robert Haas wrote:\\n> > Can you explain why logical replication is better than binary\\n> > replication for this use-case?\\n> \\n> Uh, well, for the same reasons it is better in many other cases.\\n> Particularly, you probably don't want to replicate all the data on\\n> machine A to machine B, just some of it.\\n> \\n> Typically, sharding solutions store multiple copies of each piece of\\n> data. So let's say you have 4 machines. You divide the data into 12\\n> chunks. Each machine is the write-master for 2 of those chunks, but\\n> has secondary copies of 3 others. So maybe things start out like\\n> this:\\n> \\n> machine #1: master for chunks 1, 2, 3; also has copies of chunks 4, 7, 10\\n> machine #2: master for chunks 4, 5, 6; also has copies of chunks 1, 8, 11\\n> machine #3: master for chunks 7, 8, 9; also has copies of chunks 2, 5, 12\\n> machine #4: master for chunks 10, 11, 12; also has copies of chunks 3, 6, 9\\n> \\n> If machine #1 is run over by a rabid triceratops, you can make machine\\n> #2 the master for chunk 1, machine #3 the master for chunk 2, and\\n> machine #4 the master for chunk 3. The write load therefore remains\\n> evenly divided. If you can only copy entire machines, you can't\\n> achieve that in this situation.\\n\\nI see the advantage of this now. My original idea is that each shard\\nwould have its own standby for disaster recovery, but your approach\\nabove, which I know is typical, allows the shards to back up each other.\\nYou could say shard 2 is the backup for shard 1, but then if shard one\\ngoes bad, the entire workload of shard 1 goes to shard 2. With the\\nabove approach, the load of shard 1 is shared by all the shards.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Wed, 2 Sep 2015 23:01:31 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 3, 2015 at 8:28 AM, Bruce Momjian <bruce@momjian.us> wrote:\\n>\\n> On Wed, Sep 2, 2015 at 07:50:25PM -0700, Joshua Drake wrote:\\n> > >Can you explain why logical replication is better than binary\\n> > >replication for this use-case?\\n> > >\\n> >\\n> > Selectivity?\\n>\\n> I was assuming you would just create identical slaves to handle failure,\\n> rather than moving selected data around.\\n>\\n\\nYes, I also think so, otherwise when the shard goes down and it's replica\\nhas to take the place of shard, it will take more time to make replica\\navailable as it won't have all the data as original shard had.\\n\\n\\nWith Regards,\\nAmit Kapila.\\nEnterpriseDB: http://www.enterprisedb.com\\n\\nOn Thu, Sep 3, 2015 at 8:28 AM, Bruce Momjian <bruce@momjian.us> wrote:>> On Wed, Sep 2, 2015 at 07:50:25PM -0700, Joshua Drake wrote:> > >Can you explain why logical replication is better than binary> > >replication for this use-case?> > >> >> > Selectivity?>> I was assuming you would just create identical slaves to handle failure,> rather than moving selected data around.>Yes, I also think so, otherwise when the shard goes down and it's replicahas to take the place of shard, it will take more time to make replicaavailable as it won't have all the data as original shard had. With Regards,Amit Kapila.EnterpriseDB: http://www.enterprisedb.com\",\n \"msg_date\": \"Thu, 3 Sep 2015 08:32:34 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 2, 2015 at 9:04 PM, Oleg Bartunov <obartunov@gmail.com> wrote:\\n\\n>\\n>\\n>\\n> One lesson from XL we got is that we need testing framework for cluster,\\n> so any cluster project should at least pass functional and performance\\n> testing.\\n>\\n\\n+1. In early XC days, we focused a lot on adding newer features and\\nsupporting as many PG features as possible. That took its toll on the\\ntesting and QA. It was a mistake though my feeling was we tried to correct\\nthat to some extend with XL. We did a 9.5 merge, which of course was a big\\ndeal, but other than more time is being spent on improving stability and\\nperformance\\n\\nXL was very easy to break and I'm wondering how many corner cases still\\n> exists.\\n>\\n\\nYour team reported 2 or 3 major issues which I think we were able to fix\\nquite quickly. But if there are more such issues which your team has\\nrecorded somewhere, I would request you to send them to the XL mailing\\nlist. I would definitely want to look at them and address them.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Wed, Sep 2, 2015 at 9:04 PM, Oleg Bartunov <obartunov@gmail.com> wrote:One lesson from XL we got is that we need testing framework for cluster, so any cluster project should at least pass functional and performance testing.+1. In early XC days, we focused a lot on adding newer features and supporting as many PG features as possible. That took its toll on the testing and QA. It was a mistake though my feeling was we tried to correct that to some extend with XL. We did a 9.5 merge, which of course was a big deal, but other than more time is being spent on improving stability and performance XL was very easy to break and I'm wondering how many corner cases still exists. Your team reported 2 or 3 major issues which I think we were able to fix quite quickly. But if there are more such issues which your team has recorded somewhere, I would request you to send them to the XL mailing list. I would definitely want to look at them and address them.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Thu, 3 Sep 2015 11:01:57 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \">> One lesson from XL we got is that we need testing framework for cluster,\\n>> so any cluster project should at least pass functional and performance\\n>> testing.\\n>>\\n> \\n> +1. In early XC days, we focused a lot on adding newer features and\\n> supporting as many PG features as possible. That took its toll on the\\n> testing and QA. It was a mistake though my feeling was we tried to correct\\n> that to some extend with XL. We did a 9.5 merge, which of course was a big\\n> deal, but other than more time is being spent on improving stability and\\n> performance\\n\\nAgreed. Any cluster project needs a cluster testing framework.\\n\\npgpool-II project runs \\\"build farm\\\" which runs cluster regression\\ntests every day. The tests includes several versions of pgpool-II and\\nPostgreSQL combinations using docker. Still it needs more tests but\\neven with limited test cases, it is pretty usefull to detect bugs.\\n\\nBest regards,\\n--\\nTatsuo Ishii\\nSRA OSS, Inc. Japan\\nEnglish: http://www.sraoss.co.jp/index_en.php\\nJapanese:http://www.sraoss.co.jp\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 03 Sep 2015 14:42:02 +0900 (JST)\",\n \"msg_from\": \"Tatsuo Ishii <ishii@postgresql.org>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nOn 09/03/2015 05:02 AM, Amit Kapila wrote:\\n> On Thu, Sep 3, 2015 at 8:28 AM, Bruce Momjian <bruce@momjian.us\\n> <mailto:bruce@momjian.us>> wrote:\\n> >\\n> > On Wed, Sep 2, 2015 at 07:50:25PM -0700, Joshua Drake wrote:\\n> > > >Can you explain why logical replication is better than binary\\n> > > >replication for this use-case?\\n> > > >\\n> > >\\n> > > Selectivity?\\n> >\\n>> I was assuming you would just create identical slaves to handle\\n>> failure, rather than moving selected data around.\\n> >\\n>\\n> Yes, I also think so, otherwise when the shard goes down and it's\\n> replica has to take the place of shard, it will take more time to\\n> make replica available as it won't have all the data as original\\n> shard had.\\n\\nNot really, the idea is that you don't need to create the replica \\nimmediately. The system recognizes that primary shard location is \\nunavailable and redirects the tasks to the \\\"replicas.\\\" So the time to \\nrecreate the failed node is not that critical.\\n\\nIt needs to be done in a smart way to prevent some typical issues like \\nsuddenly doubling the load on replicas due to failure of the primary \\nlocation. By using different group of nodes for each \\\"data segment\\\" you \\ncan eliminate this, because the group of nodes to handle the additional \\nload will be larger.\\n\\nThe other issue then of course is that the groups of nodes must not be \\nentirely random, otherwise the cluster would suffer data loss in case of \\noutage of arbitrary group of K nodes (where K is the number of replicas \\nfor each piece of data).\\n\\nIt's also non-trivial to do this when you have to consider racks, data \\ncenters etc.\\n\\nWith regular slaves you can't do any of this - no matter what you do, \\nyou have to load balance the additional load only on the slaves.\\n\\nregards\\n\\n--\\nTomas Vondra http://www.2ndQuadrant.com\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 03 Sep 2015 15:40:40 +0200\",\n \"msg_from\": \"Tomas Vondra <tomas.vondra@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"Josh Berkus <josh@agliodbs.com> wrote:\\n\\n>>> You'd also need a way to let the connection nodes know when a replica\\n>>> has fallen behind so that they can be taken out of\\n>>> load-balancing/sharding for read queries. For the synchronous model,\\n>>> that would be \\\"fallen behind at all\\\"; for asynchronous it would be\\n>>> \\\"fallen more than ### behind\\\".\\n>>\\n>> How is that different from the previous thing? Just that we'd treat\\n>> \\\"lagging\\\" as \\\"down\\\" beyond some threshold? That doesn't seem like a\\n>> mandatory feature.\\n>\\n> It's a mandatory feature if you want to load-balance reads. We have to\\n> know which nodes not to send reads to because they are out of sync.\\n\\nThere is another approach to this that we should consider how (if?)\\nwe are going to cover: database affinity. I have seen cases where\\nthere are multiple databases which are targets of asynchronous\\nreplication, with a web application load balancing among them. The\\napplication kept track of which copy each connection was using, so\\nthat if when they were not exactly in sync the user never saw \\\"time\\nmoving backward\\\". Two different users might see versions of the\\ndata from different points in time, but that generally doesn't\\nmatter, especially if the difference is just a few minutes. If one\\ncopy got too far behind for some reason, they would load-shift to\\nthe other servers (time still moves forward, only there is a \\\"jump\\\"\\nforward at the shift). This would allow the tardy database to be\\ndedicated to catching up again.\\n\\nBottom line is that this very smooth behavior required two features\\n-- the ability for the application to control database affinity,\\nand the ability to shift that affinity gracefully (with no down\\ntime).\\n\\n--\\nKevin Grittner\\nEDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 3 Sep 2015 14:00:17 +0000 (UTC)\",\n \"msg_from\": \"Kevin Grittner <kgrittn@ymail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 3, 2015 at 03:40:40PM +0200, Tomas Vondra wrote:\\n> Not really, the idea is that you don't need to create the replica\\n> immediately. The system recognizes that primary shard location is\\n> unavailable and redirects the tasks to the \\\"replicas.\\\" So the time\\n> to recreate the failed node is not that critical.\\n> \\n> It needs to be done in a smart way to prevent some typical issues\\n> like suddenly doubling the load on replicas due to failure of the\\n> primary location. By using different group of nodes for each \\\"data\\n> segment\\\" you can eliminate this, because the group of nodes to\\n> handle the additional load will be larger.\\n> \\n> The other issue then of course is that the groups of nodes must not\\n> be entirely random, otherwise the cluster would suffer data loss in\\n> case of outage of arbitrary group of K nodes (where K is the number\\n> of replicas for each piece of data).\\n> \\n> It's also non-trivial to do this when you have to consider racks,\\n> data centers etc.\\n> \\n> With regular slaves you can't do any of this - no matter what you\\n> do, you have to load balance the additional load only on the slaves.\\n\\nYes, and imagine doing this with FDW's, updating the catalog table\\nlocation of the FDW as part of the failover process --- interesting.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n + Everyone has their own god. +\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Thu, 3 Sep 2015 10:02:10 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"Hey Robert,\\n\\nNow the question is, where should the code that does all of this live?\\n> postgres_fdw? Some new, sharding-specific FDW? In core? I don't\\n> know for sure, but what I do know is that we could make a lot of\\n> progress over where we are today by just improving postgres_fdw, and I\\n> don't think those improvements are even all that difficult. If we\\n> decide we need to implement something new, it's going to be a huge\\n> project that will take years to complete, with uncertain results. I'd\\n> rather have a postgres_fdw-based implementation that is imperfect and\\n> can't handle some kinds of queries in 9.6 than a promise that by 9.9\\n> we'll have something really great that handles MPP perfectly.\\n>\\n\\nDistributed shuffles (Map/Reduce) are hard. When we looked at using FDWs\\nfor pg_shard, we thought that Map/Reduce would require a comprehensive\\nrevamp of the APIs.\\n\\nFor Citus, a second part of the question is as FDW writers. We implemented\\ncstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't benefit from\\neven the simple join pushdown that doesn't require Map/Reduce.\\n\\nThe PostgreSQL wiki lists 85 foreign data wrappers, and only 18 of these\\nhave support for joins:\\nhttps://wiki.postgresql.org/wiki/Foreign_data_wrappers\\n\\nBest,\\nOzgun\\n\\nHey Robert,Now the question is, where should the code that does all of this live?\\n postgres_fdw? Some new, sharding-specific FDW? In core? I don't\\nknow for sure, but what I do know is that we could make a lot of\\nprogress over where we are today by just improving postgres_fdw, and I\\ndon't think those improvements are even all that difficult. If we\\ndecide we need to implement something new, it's going to be a huge\\nproject that will take years to complete, with uncertain results. I'd\\nrather have a postgres_fdw-based implementation that is imperfect and\\ncan't handle some kinds of queries in 9.6 than a promise that by 9.9\\nwe'll have something really great that handles MPP perfectly.Distributed shuffles (Map/Reduce) are hard. When we looked at using FDWs for pg_shard, we thought that Map/Reduce would require a comprehensive revamp of the APIs.For Citus, a second part of the question is as FDW writers. We implemented cstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't benefit from even the simple join pushdown that doesn't require Map/Reduce.The PostgreSQL wiki lists 85 foreign data wrappers, and only 18 of these have support for joins: https://wiki.postgresql.org/wiki/Foreign_data_wrappersBest,Ozgun\",\n \"msg_date\": \"Fri, 4 Sep 2015 15:52:49 -0700\",\n \"msg_from\": \"Ozgun Erdogan <ozgun@citusdata.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Sat, Sep 5, 2015 at 4:22 AM, Ozgun Erdogan <ozgun@citusdata.com> wrote:\\n\\n> Hey Robert,\\n>\\n> Now the question is, where should the code that does all of this live?\\n>> postgres_fdw? Some new, sharding-specific FDW? In core? I don't\\n>> know for sure, but what I do know is that we could make a lot of\\n>> progress over where we are today by just improving postgres_fdw, and I\\n>> don't think those improvements are even all that difficult. If we\\n>> decide we need to implement something new, it's going to be a huge\\n>> project that will take years to complete, with uncertain results. I'd\\n>> rather have a postgres_fdw-based implementation that is imperfect and\\n>> can't handle some kinds of queries in 9.6 than a promise that by 9.9\\n>> we'll have something really great that handles MPP perfectly.\\n>>\\n>\\n> Distributed shuffles (Map/Reduce) are hard. When we looked at using FDWs\\n> for pg_shard, we thought that Map/Reduce would require a comprehensive\\n> revamp of the APIs.\\n>\\n> For Citus, a second part of the question is as FDW writers. We implemented\\n> cstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't benefit from\\n> even the simple join pushdown that doesn't require Map/Reduce.\\n>\\n\\nI didn't get this. Join pushdown infrastructure (chiefly set of hooks\\nprovided in join planning paths) is part of 9.5. Isn't that sufficient to\\nimplement join push-down for above FDWs? Or FDW writers are facing problems\\nwhile implementing those hooks. In either case that should be reported on\\nhackers.\\n\\n\\n>\\n> The PostgreSQL wiki lists 85 foreign data wrappers, and only 18 of these\\n> have support for joins:\\n> https://wiki.postgresql.org/wiki/Foreign_data_wrappers\\n>\\n> Best,\\n> Ozgun\\n>\\n\\n\\n\\n-- \\nBest Wishes,\\nAshutosh Bapat\\nEnterpriseDB Corporation\\nThe Postgres Database Company\\n\\nOn Sat, Sep 5, 2015 at 4:22 AM, Ozgun Erdogan <ozgun@citusdata.com> wrote:Hey Robert,Now the question is, where should the code that does all of this live?\\n postgres_fdw? Some new, sharding-specific FDW? In core? I don't\\nknow for sure, but what I do know is that we could make a lot of\\nprogress over where we are today by just improving postgres_fdw, and I\\ndon't think those improvements are even all that difficult. If we\\ndecide we need to implement something new, it's going to be a huge\\nproject that will take years to complete, with uncertain results. I'd\\nrather have a postgres_fdw-based implementation that is imperfect and\\ncan't handle some kinds of queries in 9.6 than a promise that by 9.9\\nwe'll have something really great that handles MPP perfectly.Distributed shuffles (Map/Reduce) are hard. When we looked at using FDWs for pg_shard, we thought that Map/Reduce would require a comprehensive revamp of the APIs.For Citus, a second part of the question is as FDW writers. We implemented cstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't benefit from even the simple join pushdown that doesn't require Map/Reduce.I didn't get this. Join pushdown infrastructure (chiefly set of hooks provided in join planning paths) is part of 9.5. Isn't that sufficient to implement join push-down for above FDWs? Or FDW writers are facing problems while implementing those hooks. In either case that should be reported on hackers. The PostgreSQL wiki lists 85 foreign data wrappers, and only 18 of these have support for joins: https://wiki.postgresql.org/wiki/Foreign_data_wrappersBest,Ozgun\\n-- Best Wishes,Ashutosh BapatEnterpriseDB CorporationThe Postgres Database Company\",\n \"msg_date\": \"Mon, 7 Sep 2015 11:13:39 +0530\",\n \"msg_from\": \"Ashutosh Bapat <ashutosh.bapat@enterprisedb.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"I\\n\\nOn Monday, September 7, 2015, Ashutosh Bapat <\\nashutosh.bapat@enterprisedb.com> wrote:\\n\\n>\\n>\\n> On Sat, Sep 5, 2015 at 4:22 AM, Ozgun Erdogan <ozgun@citusdata.com\\n> <javascript:_e(%7B%7D,'cvml','ozgun@citusdata.com');>> wrote:\\n>\\n>> Hey Robert,\\n>>\\n>> Now the question is, where should the code that does all of this live?\\n>>> postgres_fdw? Some new, sharding-specific FDW? In core? I don't\\n>>> know for sure, but what I do know is that we could make a lot of\\n>>> progress over where we are today by just improving postgres_fdw, and I\\n>>> don't think those improvements are even all that difficult. If we\\n>>> decide we need to implement something new, it's going to be a huge\\n>>> project that will take years to complete, with uncertain results. I'd\\n>>> rather have a postgres_fdw-based implementation that is imperfect and\\n>>> can't handle some kinds of queries in 9.6 than a promise that by 9.9\\n>>> we'll have something really great that handles MPP perfectly.\\n>>>\\n>>\\n>> Distributed shuffles (Map/Reduce) are hard. When we looked at using FDWs\\n>> for pg_shard, we thought that Map/Reduce would require a comprehensive\\n>> revamp of the APIs.\\n>>\\n>> For Citus, a second part of the question is as FDW writers. We\\n>> implemented cstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't\\n>> benefit from even the simple join pushdown that doesn't require Map/Reduce.\\n>>\\n>\\n> I didn't get this. Join pushdown infrastructure (chiefly set of hooks\\n> provided in join planning paths) is part of 9.5. Isn't that sufficient to\\n> implement join push-down for above FDWs? Or FDW writers are facing problems\\n> while implementing those hooks. In either case that should be reported on\\n> hackers.\\n>\\n>\\n\\nI don't think any FDW writer (other the postgres_fdw) has tried to\\nimplement join push down in the respective FDW's using the new API.\\n\\n\\n>\\n>> The PostgreSQL wiki lists 85 foreign data wrappers, and only 18 of these\\n>> have support for joins:\\n>> https://wiki.postgresql.org/wiki/Foreign_data_wrappers\\n>>\\n>> Best,\\n>> Ozgun\\n>>\\n>\\n>\\n>\\n> --\\n> Best Wishes,\\n> Ashutosh Bapat\\n> EnterpriseDB Corporation\\n> The Postgres Database Company\\n>\\n\\n\\n-- \\nAhsan Hadi\\nSnr Director Product Development\\nEnterpriseDB Corporation\\nThe Enterprise Postgres Company\\n\\nPhone: +92-51-8358874\\nMobile: +92-333-5162114\\n\\nWebsite: www.enterprisedb.com\\nEnterpriseDB Blog: http://blogs.enterprisedb.com/\\nFollow us on Twitter: http://www.twitter.com/enterprisedb\\n\\nThis e-mail message (and any attachment) is intended for the use of the\\nindividual or entity to whom it is addressed. This message contains\\ninformation from EnterpriseDB Corporation that may be privileged,\\nconfidential, or exempt from disclosure under applicable law. If you are\\nnot the intended recipient or authorized to receive this for the intended\\nrecipient, any use, dissemination, distribution, retention, archiving, or\\ncopying of this communication is strictly prohibited. If you have received\\nthis e-mail in error, please notify the sender immediately by reply e-mail\\nand delete this message.\\n\\nI On Monday, September 7, 2015, Ashutosh Bapat <ashutosh.bapat@enterprisedb.com> wrote:On Sat, Sep 5, 2015 at 4:22 AM, Ozgun Erdogan <ozgun@citusdata.com> wrote:Hey Robert,Now the question is, where should the code that does all of this live?\\n postgres_fdw? Some new, sharding-specific FDW? In core? I don't\\nknow for sure, but what I do know is that we could make a lot of\\nprogress over where we are today by just improving postgres_fdw, and I\\ndon't think those improvements are even all that difficult. If we\\ndecide we need to implement something new, it's going to be a huge\\nproject that will take years to complete, with uncertain results. I'd\\nrather have a postgres_fdw-based implementation that is imperfect and\\ncan't handle some kinds of queries in 9.6 than a promise that by 9.9\\nwe'll have something really great that handles MPP perfectly.Distributed shuffles (Map/Reduce) are hard. When we looked at using FDWs for pg_shard, we thought that Map/Reduce would require a comprehensive revamp of the APIs.For Citus, a second part of the question is as FDW writers. We implemented cstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't benefit from even the simple join pushdown that doesn't require Map/Reduce.I didn't get this. Join pushdown infrastructure (chiefly set of hooks provided in join planning paths) is part of 9.5. Isn't that sufficient to implement join push-down for above FDWs? Or FDW writers are facing problems while implementing those hooks. In either case that should be reported on hackers. I don't think any FDW writer (other the postgres_fdw) has tried to implement join push down in the respective FDW's using the new API. The PostgreSQL wiki lists 85 foreign data wrappers, and only 18 of these have support for joins: https://wiki.postgresql.org/wiki/Foreign_data_wrappersBest,Ozgun\\n-- Best Wishes,Ashutosh BapatEnterpriseDB CorporationThe Postgres Database Company\\n\\n-- Ahsan HadiSnr Director Product DevelopmentEnterpriseDB CorporationThe Enterprise Postgres CompanyPhone: +92-51-8358874 Mobile: +92-333-5162114Website: www.enterprisedb.comEnterpriseDB Blog: http://blogs.enterprisedb.com/Follow us on Twitter: http://www.twitter.com/enterprisedbThis e-mail message (and any attachment) is intended for the use of the individual or entity to whom it is addressed. This message contains information from EnterpriseDB Corporation that may be privileged, confidential, or exempt from disclosure under applicable law. If you are not the intended recipient or authorized to receive this for the intended recipient, any use, dissemination, distribution, retention, archiving, or copying of this communication is strictly prohibited. If you have received this e-mail in error, please notify the sender immediately by reply e-mail and delete this message.\",\n \"msg_date\": \"Mon, 7 Sep 2015 23:33:08 +0500\",\n \"msg_from\": \"Ahsan Hadi <ahsan.hadi@enterprisedb.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Thu, Sep 3, 2015 at 7:03 AM, Josh Berkus <josh@agliodbs.com> wrote:\\n\\n> On 09/02/2015 11:41 AM, Robert Haas wrote:\\n> > 4. Therefore, I think that we should instead use logical replication,\\n> > which might be either synchronous or asynchronous. When you modify\\n> > one copy of the data, that change will then be replicated to all other\\n> > nodes. If you are OK with eventual consistency, this replication can\\n> > be asynchronous, and nodes that are off-line will catch up when they\\n> > are on-line. If you are not OK with that, then you must replicate\\n> > synchronously to every node before transaction commit; or at least you\\n> > must replicate synchronously to every node that is currently on-line.\\n> > This presents some challenges: logical decoding currently can't\\n> > replicate transactions that are still in process - replication starts\\n> > when the transaction commits. Also, we don't have any way for\\n> > synchronous replication to wait for multiple nodes.\\n>\\n> Well, there is a WIP patch for that, which IMHO would be much improved\\n> by having a concrete use-case like this one. What nobody is working on\\n> -- and we've vetoed in the past -- is a way of automatically failing and\\n> removing from replication any node which repeatedly fails to sync, which\\n> would be a requirement for this model.\\n>\\n> You'd also need a way to let the connection nodes know when a replica\\n> has fallen behind so that they can be taken out of\\n> load-balancing/sharding for read queries. For the synchronous model,\\n> that would be \\\"fallen behind at all\\\"; for asynchronous it would be\\n> \\\"fallen more than ### behind\\\".\\n>\\n\\nI have been thinking about that problem in the context of\\nsynchronous_commit = apply, and while trying to review the multiple\\nsynchronous patch. How are you supposed to actually make use of\\nremote-apply semantics without a way to find a replica that is consistent?\\nAnd what does consistent mean? I'm going to say consistency means: it sees\\nat least all effects of all preceding COMMITs that returned successfully.\\nIt's trivial in a no-timeout, single standby topology (if commit returned,\\nthe sole sync replica has applied your transaction and replied), but beyond\\nthat it obviously requires some more infrastructure and concepts. Here is\\nmy suggestion:\\n\\nImagine if we could configure setups like this:\\n\\n1. I have 4 servers called london1, london2, paris1, paris2 (see nearby\\nmultiple sync server thread/patch).\\n2. I have synchronous_commit = apply (see nearby thread/patch)\\n3. Currently london1 is master, with the other 3 in the synchronous\\nreplication set, and I want a minimum replication set of size 2 so I can\\nlose 1 of those and continue\\n\\nSo far so good, now for the double-vapourware part:\\n\\n4. The replicas know whether they are currently part of the master's\\nsynchronous replication set or not because it tells them\\n5. While waiting for replicas, the master only waits up to X milliseconds,\\nand if no reply is received from a given server it drops that server from\\nthe sync rep set, like a RAID controller dropping an unresponsive element\\nfrom a RAID array, but still returns control to the user if 2 nodes (our\\nconfigured minimum) did reply\\n6. If the sync rep set reaches our minimum size 2 because of a node being\\ndropped, then you can no longer drop one, so commit hangs (work is blocked\\nuntil enough servers connect and catch up again)\\n7. If a replica sees that it hasn't received WAL records or pings from the\\nmaster with timestamps from the past Y milliseconds, or receives a message\\nexplicitly telling it it's been dropped from the sync rep set, it will\\nstart rejecting my queries on the basis that it's potentially out of date\\n8. If the master sees suitable apply reply messages stream in from a node\\nthat was dropped but has now caught up (possibly having reconnected), it\\nwill explicitly tell it that it's back in the sync rep set and start\\nwaiting for it again\\n9. X is sufficiently larger than Y so that, combined with the 'you've been\\ndropped from/rejoined the sync rep set' messages and well sync'd system\\nclocks, it should not be possible for a replica to expose snapshots that\\ndon't include all effects from transactions whose COMMIT command returned\\non the master. (If you don't have the concept of a dynamic replication set\\nwhich replicas are dropped from and rejoin, then the master can't drop a\\nnode and carry on, like a RAID controller would, unless it's happy to wait\\nfor any old N nodes to reply. Waiting for any N nodes to reply may be OK\\nfor log-flush-only sync rep, but if you want to use apply sync rep and have\\nguarantees about visibility, and you simply wait for any N nodes to reply,\\nthen the nodes themselves don't know if they are up to date with master or\\nnot (they don't know if they were one of the ones that master waited for\\nsome transaction they haven't even heard about yet), so they may show users\\nold data. Also, if you don't have the master telling the replicas that it\\nconsiders them to be in or out of the replication set, they don't know\\nexactly when the master decides to consider them in again after they\\nrejoin.)\\n\\nNow I can connect to any server and specify my requirement to see all\\ncommitted-on-the-master transactions (meaning: the COMMIT command returned\\nsuccess to the client), and either get an error telling me that it can't\\nguarantee that at that moment (because it has been told it's not in the\\nsync rep set or hasn't heard from the master recently enough), or happily\\nproceed to query the database. I can send my writes to the master node,\\nand do all my reads on any node I like, and be sure they include whatever I\\njust committed (or someone else just committed and told me about). I can\\nalso use FDW to query the replicas from the master and know that they can\\nsee everything already committed (but of course not uncommitted changes;\\nI'm guessing you get that on the GTM based systems).\\n\\nThe main problem I can see so far with this scheme is that you can see\\nthings on the replicas *before* the COMMIT returns. Is that a problem? I\\nsuspect all solutions to that problem involve centralised snapshot control\\n(through a GTM or through the master).\\n\\nThe timeout and ping based drop/join idea is inspired by a non-Postgres\\nsystem that was presented at CHAR(14) last year that is due to be released\\nas open source one day (and whose author egged me on to try implementing\\nthat synchronous_commit = apply patch), and I guess loosely RAID. Maybe\\nthere is better terminology or a name in database literature for this\\napproach, I'm not sure, and maybe it has unacceptable holes. It's a lot\\nless radical than the GTM/MPP systems, since it just adds a few bells and\\nwhistles to the existing single master replication model, and obviously\\nthere are plenty more problems to solve to make really useful clustering\\ntechnology, like master reelection, query routing/node location, load\\nbalancing and so forth. But the master and the replicas have the\\ninformation they need to do that.\\n\\n-- \\nThomas Munro\\nhttp://www.enterprisedb.com\\n\\nOn Thu, Sep 3, 2015 at 7:03 AM, Josh Berkus <josh@agliodbs.com> wrote:On 09/02/2015 11:41 AM, Robert Haas wrote:\\n> 4. Therefore, I think that we should instead use logical replication,\\n> which might be either synchronous or asynchronous. When you modify\\n> one copy of the data, that change will then be replicated to all other\\n> nodes. If you are OK with eventual consistency, this replication can\\n> be asynchronous, and nodes that are off-line will catch up when they\\n> are on-line. If you are not OK with that, then you must replicate\\n> synchronously to every node before transaction commit; or at least you\\n> must replicate synchronously to every node that is currently on-line.\\n> This presents some challenges: logical decoding currently can't\\n> replicate transactions that are still in process - replication starts\\n> when the transaction commits. Also, we don't have any way for\\n> synchronous replication to wait for multiple nodes.\\n\\nWell, there is a WIP patch for that, which IMHO would be much improved\\nby having a concrete use-case like this one. What nobody is working on\\n-- and we've vetoed in the past -- is a way of automatically failing and\\nremoving from replication any node which repeatedly fails to sync, which\\nwould be a requirement for this model.\\n\\nYou'd also need a way to let the connection nodes know when a replica\\nhas fallen behind so that they can be taken out of\\nload-balancing/sharding for read queries. For the synchronous model,\\nthat would be \\\"fallen behind at all\\\"; for asynchronous it would be\\n\\\"fallen more than ### behind\\\".I have been thinking about that problem in the context of synchronous_commit = apply, and while trying to review the multiple synchronous patch. How are you supposed to actually make use of remote-apply semantics without a way to find a replica that is consistent? And what does consistent mean? I'm going to say consistency means: it sees at least all effects of all preceding COMMITs that returned successfully. It's trivial in a no-timeout, single standby topology (if commit returned, the sole sync replica has applied your transaction and replied), but beyond that it obviously requires some more infrastructure and concepts. Here is my suggestion:Imagine if we could configure setups like this:1. I have 4 servers called london1, london2, paris1, paris2 (see nearby multiple sync server thread/patch).2. I have synchronous_commit = apply (see nearby thread/patch)3. Currently london1 is master, with the other 3 in the synchronous replication set, and I want a minimum replication set of size 2 so I can lose 1 of those and continueSo far so good, now for the double-vapourware part:4. The replicas know whether they are currently part of the master's synchronous replication set or not because it tells them5. While waiting for replicas, the master only waits up to X milliseconds, and if no reply is received from a given server it drops that server from the sync rep set, like a RAID controller dropping an unresponsive element from a RAID array, but still returns control to the user if 2 nodes (our configured minimum) did reply6. If the sync rep set reaches our minimum size 2 because of a node being dropped, then you can no longer drop one, so commit hangs (work is blocked until enough servers connect and catch up again)7. If a replica sees that it hasn't received WAL records or pings from the master with timestamps from the past Y milliseconds, or receives a message explicitly telling it it's been dropped from the sync rep set, it will start rejecting my queries on the basis that it's potentially out of date8. If the master sees suitable apply reply messages stream in from a node that was dropped but has now caught up (possibly having reconnected), it will explicitly tell it that it's back in the sync rep set and start waiting for it again9. X is sufficiently larger than Y so that, combined with the 'you've been dropped from/rejoined the sync rep set' messages and well sync'd system clocks, it should not be possible for a replica to expose snapshots that don't include all effects from transactions whose COMMIT command returned on the master. (If you don't have the concept of a dynamic replication set which replicas are dropped from and rejoin, then the master can't drop a node and carry on, like a RAID controller would, unless it's happy to wait for any old N nodes to reply. Waiting for any N nodes to reply may be OK for log-flush-only sync rep, but if you want to use apply sync rep and have guarantees about visibility, and you simply wait for any N nodes to reply, then the nodes themselves don't know if they are up to date with master or not (they don't know if they were one of the ones that master waited for some transaction they haven't even heard about yet), so they may show users old data. Also, if you don't have the master telling the replicas that it considers them to be in or out of the replication set, they don't know exactly when the master decides to consider them in again after they rejoin.)Now I can connect to any server and specify my requirement to see all committed-on-the-master transactions (meaning: the COMMIT command returned success to the client), and either get an error telling me that it can't guarantee that at that moment (because it has been told it's not in the sync rep set or hasn't heard from the master recently enough), or happily proceed to query the database. I can send my writes to the master node, and do all my reads on any node I like, and be sure they include whatever I just committed (or someone else just committed and told me about). I can also use FDW to query the replicas from the master and know that they can see everything already committed (but of course not uncommitted changes; I'm guessing you get that on the GTM based systems).The main problem I can see so far with this scheme is that you can see things on the replicas *before* the COMMIT returns. Is that a problem? I suspect all solutions to that problem involve centralised snapshot control (through a GTM or through the master).The timeout and ping based drop/join idea is inspired by a non-Postgres system that was presented at CHAR(14) last year that is due to be released as open source one day (and whose author egged me on to try implementing that synchronous_commit = apply patch), and I guess loosely RAID. Maybe there is better terminology or a name in database literature for this approach, I'm not sure, and maybe it has unacceptable holes. It's a lot less radical than the GTM/MPP systems, since it just adds a few bells and whistles to the existing single master replication model, and obviously there are plenty more problems to solve to make really useful clustering technology, like master reelection, query routing/node location, load balancing and so forth. But the master and the replicas have the information they need to do that.-- Thomas Munrohttp://www.enterprisedb.com\",\n \"msg_date\": \"Tue, 8 Sep 2015 18:25:00 +1200\",\n \"msg_from\": \"Thomas Munro <thomas.munro@enterprisedb.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Fri, Sep 4, 2015 at 6:52 PM, Ozgun Erdogan <ozgun@citusdata.com> wrote:\\n> Distributed shuffles (Map/Reduce) are hard. When we looked at using FDWs for\\n> pg_shard, we thought that Map/Reduce would require a comprehensive revamp of\\n> the APIs.\\n\\nWell, so you've said. But what kind of API do you want to see?\\nTaking control at some very high-level hook like ExecutorRun() is not\\nreally a maintainable solution - it's fine if you've only got one guy\\ndoing it, perhaps, but if you have several FDWs talking to different\\nkinds of remote systems, they can't all seize overall control.\\n\\n>> For Citus, a second part of the question is as FDW writers. We implemented\\n> cstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't benefit from\\n> even the simple join pushdown that doesn't require Map/Reduce.\\n>\\n> The PostgreSQL wiki lists 85 foreign data wrappers, and only 18 of these\\n> have support for joins:\\n> https://wiki.postgresql.org/wiki/Foreign_data_wrappers\\n\\nWhat do you mean by \\\"support for joins\\\"? Do you mean that only 18 of\\nthe remote data sources can do joins? If so, why does that matter?\\nI'd be quite happy if a join pushdown or \\\"distributed shuffle\\\" API had\\nas many as 18 users - I'd be quite happy if it had one (postgres_fdw).\\nThe fact that not all FDWs can support every operation because of\\nlimitations on the remote side isn't a reason not to support those\\noperations when the remote side is capable.\\n\\n-- \\nRobert Haas\\nEnterpriseDB: http://www.enterprisedb.com\\nThe Enterprise PostgreSQL Company\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 8 Sep 2015 13:52:52 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On 2015-09-08 19:52, Robert Haas wrote:\\n> On Fri, Sep 4, 2015 at 6:52 PM, Ozgun Erdogan <ozgun@citusdata.com> wrote:\\n>>> For Citus, a second part of the question is as FDW writers. We implemented\\n>> cstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't benefit from\\n>> even the simple join pushdown that doesn't require Map/Reduce.\\n>>\\n>> The PostgreSQL wiki lists 85 foreign data wrappers, and only 18 of these\\n>> have support for joins:\\n>> https://wiki.postgresql.org/wiki/Foreign_data_wrappers\\n>\\n> What do you mean by \\\"support for joins\\\"? Do you mean that only 18 of\\n> the remote data sources can do joins? If so, why does that matter?\\n> I'd be quite happy if a join pushdown or \\\"distributed shuffle\\\" API had\\n> as many as 18 users - I'd be quite happy if it had one (postgres_fdw).\\n> The fact that not all FDWs can support every operation because of\\n> limitations on the remote side isn't a reason not to support those\\n> operations when the remote side is capable.\\n>\\n\\nAgreed. While I personally don't think FDWs are long term answer for \\nsharding, I do believe that the infrastructure that is being developed \\nfor FDWs (join/aggregate pushdown) is needed anyway and there are many \\ncommon issues that need solving in this area for FDWs, sharding and \\nparallel query.\\n\\n-- \\n Petr Jelinek http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 8 Sep 2015 20:40:42 +0200\",\n \"msg_from\": \"Petr Jelinek <petr@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n },\n {\n \"msg_contents\": \"On Mon, Sep 7, 2015 at 1:33 PM, Ahsan Hadi <ahsan.hadi@enterprisedb.com> wrote:\\n> I\\n>\\n> On Monday, September 7, 2015, Ashutosh Bapat\\n> <ashutosh.bapat@enterprisedb.com> wrote:\\n>>\\n>>\\n>>\\n>> On Sat, Sep 5, 2015 at 4:22 AM, Ozgun Erdogan <ozgun@citusdata.com> wrote:\\n>>>\\n>>> Hey Robert,\\n>>>\\n>>>> Now the question is, where should the code that does all of this live?\\n>>>> postgres_fdw? Some new, sharding-specific FDW? In core? I don't\\n>>>> know for sure, but what I do know is that we could make a lot of\\n>>>> progress over where we are today by just improving postgres_fdw, and I\\n>>>> don't think those improvements are even all that difficult. If we\\n>>>> decide we need to implement something new, it's going to be a huge\\n>>>> project that will take years to complete, with uncertain results. I'd\\n>>>> rather have a postgres_fdw-based implementation that is imperfect and\\n>>>> can't handle some kinds of queries in 9.6 than a promise that by 9.9\\n>>>> we'll have something really great that handles MPP perfectly.\\n>>>\\n>>>\\n>>> Distributed shuffles (Map/Reduce) are hard. When we looked at using FDWs\\n>>> for pg_shard, we thought that Map/Reduce would require a comprehensive\\n>>> revamp of the APIs.\\n>>>\\n>>> For Citus, a second part of the question is as FDW writers. We\\n>>> implemented cstore_fdw, json_fdw, and mongo_fdw, and these wrappers don't\\n>>> benefit from even the simple join pushdown that doesn't require Map/Reduce.\\n>>\\n>>\\n>> I didn't get this. Join pushdown infrastructure (chiefly set of hooks\\n>> provided in join planning paths) is part of 9.5. Isn't that sufficient to\\n>> implement join push-down for above FDWs? Or FDW writers are facing problems\\n>> while implementing those hooks. In either case that should be reported on\\n>> hackers.\\n>>\\n>\\n>\\n> I don't think any FDW writer (other the postgres_fdw) has tried to implement\\n> join push down in the respective FDW's using the new API.\\n\\nWell, 'jdbc_fdw2' seems to implement deparsing at some level:\\nhttps://github.com/heimir-sverrisson/jdbc2_fdw/blob/master/deparse.c\\n\\n...but this was likely a copy/paste job from the postgres_fdw. It\\nshould not escape note that the deparsing strategy has dependencies on\\nthe optimizer and the parser. This is not good; asking the FDW\\nimplementations to implement SQL optimizations is not a sustainable\\nsolution. They should be indicating, for example, \\\"I support ANSI-92\\nSQL\\\", and the postgres planner should be deparsing the foreign table\\ndefinition and rewriting it, not the other way around.\\n\\nmerlin\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Tue, 8 Sep 2015 13:56:37 -0500\",\n \"msg_from\": \"Merlin Moncure <mmoncure@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Horizontal scalability/sharding\"\n }\n]","isConversational":false}}},{"rowIdx":41199,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Discovered when debugging libpqtypes test failures:\n\nhttps://bugs.debian.org/cgi-bin/bugreport.cgi?bug=795729\n\npostgres =# set timezone = 'Etc/UTC+1';\nSET\npostgres =# set datestyle = 'postgres';\nSET\npostgres =# select '2015-01-01 01:00:00 +0100'::timestamptz;\n Wed 31 Dec 23:00:00 2014 ETC/UTC\n\npostgres =# select 'Wed 31 Dec 23:00:00 2014 ETC/UTC'::timestamptz;\n Wed 31 Dec 22:00:00 2014 ETC/UTC\n\n\nThat is, feeding back a value will to the UTC offset shift again.\n(9.6 head, also seen on 9.4.)\n\nChristoph\n-- \ncb@df7cb.de | http://www.df7cb.de/\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 30 Aug 2015 12:29:45 +0200","msg_from":"Christoph Berg <cb@df7cb.de>","msg_from_op":true,"msg_subject":"datestyle=postgres broken with timezone=UTC+N"},{"msg_contents":"Christoph Berg <cb@df7cb.de> writes:\n> postgres =# set timezone = 'Etc/UTC+1';\n> SET\n> postgres =# set datestyle = 'postgres';\n> SET\n> postgres =# select '2015-01-01 01:00:00 +0100'::timestamptz;\n> Wed 31 Dec 23:00:00 2014 ETC/UTC\n\n> postgres =# select 'Wed 31 Dec 23:00:00 2014 ETC/UTC'::timestamptz;\n> Wed 31 Dec 22:00:00 2014 ETC/UTC\n\nNot sure I see your point? Lacking any entry for ETC/UTC in the\ntimezone_abbreviations file, we'll look it up in the zoneinfo database,\nand that will tell us it means UTC+0. So the input means 2300 UTC, and\nthat gets displayed as 2200 in your UTC-1 display timezone.\n\nNo, this isn't entirely consistent with the way the timezone name is being\nused in output. But that's because you've only half-configured the system\nfor a weird timezone name. You would need an abbreviation entry as well\nif you want \"ETC/UTC\" to be read as UTC-1.\n\nFor more info read\nhttp://www.postgresql.org/docs/9.4/static/datatype-datetime.html#DATATYPE-TIMEZONES\n--- see particularly the FOOBAR0 example, which is exactly what you've\ngot here. By and large, I don't recommend use of POSIX notation in\ntimezone settings; the IANA geographical zone names are much less likely\nto bite you on the rear.\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 30 Aug 2015 11:02:47 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: datestyle=postgres broken with timezone=UTC+N"},{"msg_contents":"Re: Tom Lane 2015-08-30 <20976.1440946967@sss.pgh.pa.us>\n> Christoph Berg <cb@df7cb.de> writes:\n> > postgres =# set timezone = 'Etc/UTC+1';\n> > SET\n> > postgres =# set datestyle = 'postgres';\n> > SET\n> > postgres =# select '2015-01-01 01:00:00 +0100'::timestamptz;\n> > Wed 31 Dec 23:00:00 2014 ETC/UTC\n> \n> > postgres =# select 'Wed 31 Dec 23:00:00 2014 ETC/UTC'::timestamptz;\n> > Wed 31 Dec 22:00:00 2014 ETC/UTC\n> \n> Not sure I see your point? Lacking any entry for ETC/UTC in the\n> timezone_abbreviations file, we'll look it up in the zoneinfo database,\n> and that will tell us it means UTC+0. So the input means 2300 UTC, and\n> that gets displayed as 2200 in your UTC-1 display timezone.\n> \n> No, this isn't entirely consistent with the way the timezone name is being\n> used in output. But that's because you've only half-configured the system\n> for a weird timezone name. You would need an abbreviation entry as well\n> if you want \"ETC/UTC\" to be read as UTC-1.\n> \n> For more info read\n> http://www.postgresql.org/docs/9.4/static/datatype-datetime.html#DATATYPE-TIMEZONES\n> --- see particularly the FOOBAR0 example, which is exactly what you've\n\nHi Tom,\n\nthanks for the heads-up. I have to confess that I was chasing a ghost\nhere; the original report for the libpqtypes test failure I was\ninvestigating was mentioning \"Etc/GMT+12\" (instead of UTC) which is a\nlegal zone, and with which the timestamptz output is correct even with\ndatestyle=postgres. I'll report back if the problem is on the PG or\nlibpqtypes side, sorry for the premature noise.\n\n> got here. By and large, I don't recommend use of POSIX notation in\n> timezone settings; the IANA geographical zone names are much less likely\n> to bite you on the rear.\n\nThe report is from Debian's reproducible builds project, they try to\nmake the package builds independent from as many environment factors as\npossible, and one variation they try are timezones on the far plus or\nminus side. Luckily, PostgreSQL itself is already reproducible (but\nnot cross-build friendly, more on that later), but libpqtypes got\ncaught by a TZ problem in the test suite.\n\nhttps://wiki.debian.org/ReproducibleBuilds\n\nChristoph\n-- \ncb@df7cb.de | http://www.df7cb.de/\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers\n","msg_date":"Sun, 30 Aug 2015 22:32:06 +0200","msg_from":"Christoph Berg <cb@df7cb.de>","msg_from_op":true,"msg_subject":"Re: datestyle=postgres broken with timezone=UTC+N"}],"string":"[\n {\n \"msg_contents\": \"Discovered when debugging libpqtypes test failures:\\n\\nhttps://bugs.debian.org/cgi-bin/bugreport.cgi?bug=795729\\n\\npostgres =# set timezone = 'Etc/UTC+1';\\nSET\\npostgres =# set datestyle = 'postgres';\\nSET\\npostgres =# select '2015-01-01 01:00:00 +0100'::timestamptz;\\n Wed 31 Dec 23:00:00 2014 ETC/UTC\\n\\npostgres =# select 'Wed 31 Dec 23:00:00 2014 ETC/UTC'::timestamptz;\\n Wed 31 Dec 22:00:00 2014 ETC/UTC\\n\\n\\nThat is, feeding back a value will to the UTC offset shift again.\\n(9.6 head, also seen on 9.4.)\\n\\nChristoph\\n-- \\ncb@df7cb.de | http://www.df7cb.de/\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 30 Aug 2015 12:29:45 +0200\",\n \"msg_from\": \"Christoph Berg <cb@df7cb.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"datestyle=postgres broken with timezone=UTC+N\"\n },\n {\n \"msg_contents\": \"Christoph Berg <cb@df7cb.de> writes:\\n> postgres =# set timezone = 'Etc/UTC+1';\\n> SET\\n> postgres =# set datestyle = 'postgres';\\n> SET\\n> postgres =# select '2015-01-01 01:00:00 +0100'::timestamptz;\\n> Wed 31 Dec 23:00:00 2014 ETC/UTC\\n\\n> postgres =# select 'Wed 31 Dec 23:00:00 2014 ETC/UTC'::timestamptz;\\n> Wed 31 Dec 22:00:00 2014 ETC/UTC\\n\\nNot sure I see your point? Lacking any entry for ETC/UTC in the\\ntimezone_abbreviations file, we'll look it up in the zoneinfo database,\\nand that will tell us it means UTC+0. So the input means 2300 UTC, and\\nthat gets displayed as 2200 in your UTC-1 display timezone.\\n\\nNo, this isn't entirely consistent with the way the timezone name is being\\nused in output. But that's because you've only half-configured the system\\nfor a weird timezone name. You would need an abbreviation entry as well\\nif you want \\\"ETC/UTC\\\" to be read as UTC-1.\\n\\nFor more info read\\nhttp://www.postgresql.org/docs/9.4/static/datatype-datetime.html#DATATYPE-TIMEZONES\\n--- see particularly the FOOBAR0 example, which is exactly what you've\\ngot here. By and large, I don't recommend use of POSIX notation in\\ntimezone settings; the IANA geographical zone names are much less likely\\nto bite you on the rear.\\n\\n\\t\\t\\tregards, tom lane\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 30 Aug 2015 11:02:47 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: datestyle=postgres broken with timezone=UTC+N\"\n },\n {\n \"msg_contents\": \"Re: Tom Lane 2015-08-30 <20976.1440946967@sss.pgh.pa.us>\\n> Christoph Berg <cb@df7cb.de> writes:\\n> > postgres =# set timezone = 'Etc/UTC+1';\\n> > SET\\n> > postgres =# set datestyle = 'postgres';\\n> > SET\\n> > postgres =# select '2015-01-01 01:00:00 +0100'::timestamptz;\\n> > Wed 31 Dec 23:00:00 2014 ETC/UTC\\n> \\n> > postgres =# select 'Wed 31 Dec 23:00:00 2014 ETC/UTC'::timestamptz;\\n> > Wed 31 Dec 22:00:00 2014 ETC/UTC\\n> \\n> Not sure I see your point? Lacking any entry for ETC/UTC in the\\n> timezone_abbreviations file, we'll look it up in the zoneinfo database,\\n> and that will tell us it means UTC+0. So the input means 2300 UTC, and\\n> that gets displayed as 2200 in your UTC-1 display timezone.\\n> \\n> No, this isn't entirely consistent with the way the timezone name is being\\n> used in output. But that's because you've only half-configured the system\\n> for a weird timezone name. You would need an abbreviation entry as well\\n> if you want \\\"ETC/UTC\\\" to be read as UTC-1.\\n> \\n> For more info read\\n> http://www.postgresql.org/docs/9.4/static/datatype-datetime.html#DATATYPE-TIMEZONES\\n> --- see particularly the FOOBAR0 example, which is exactly what you've\\n\\nHi Tom,\\n\\nthanks for the heads-up. I have to confess that I was chasing a ghost\\nhere; the original report for the libpqtypes test failure I was\\ninvestigating was mentioning \\\"Etc/GMT+12\\\" (instead of UTC) which is a\\nlegal zone, and with which the timestamptz output is correct even with\\ndatestyle=postgres. I'll report back if the problem is on the PG or\\nlibpqtypes side, sorry for the premature noise.\\n\\n> got here. By and large, I don't recommend use of POSIX notation in\\n> timezone settings; the IANA geographical zone names are much less likely\\n> to bite you on the rear.\\n\\nThe report is from Debian's reproducible builds project, they try to\\nmake the package builds independent from as many environment factors as\\npossible, and one variation they try are timezones on the far plus or\\nminus side. Luckily, PostgreSQL itself is already reproducible (but\\nnot cross-build friendly, more on that later), but libpqtypes got\\ncaught by a TZ problem in the test suite.\\n\\nhttps://wiki.debian.org/ReproducibleBuilds\\n\\nChristoph\\n-- \\ncb@df7cb.de | http://www.df7cb.de/\\n\\n\\n-- \\nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\\nTo make changes to your subscription:\\nhttp://www.postgresql.org/mailpref/pgsql-hackers\\n\",\n \"msg_date\": \"Sun, 30 Aug 2015 22:32:06 +0200\",\n \"msg_from\": \"Christoph Berg <cb@df7cb.de>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: datestyle=postgres broken with timezone=UTC+N\"\n }\n]","isConversational":false}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":411,"numItemsPerPage":100,"numTotalItems":58371,"offset":41100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTU2Mzc5NSwianRpIjoiMTdlNmJhYzAtNzEwNy00MDVkLWI3MzItNjM5MjhiZGE0NDM2Iiwic3ViIjoiL2RhdGFzZXRzL3dhbnNoZW5sL3Bnc3FsLWhhY2tlcnMiLCJleHAiOjE3ODU1NjczOTUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.g03IW9-GIFiz_RtFG22999z0bKD4ysc87IaNA2_slLwlRhs5h3gQLRFTBeRxS-quHgqYcT1pzT2wHXSF79i2Ag","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":58371,"numBytesParquet":368254123}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
threads listlengths 1 2.99k |
|---|
[
{
"msg_contents": "Hello Hackers,\n\nThere are a few \"Needs Review\" items remaining in the July commitfest. \nReviewers, please take action - you are holding up the commitfest.\n\nIn addition to these items, there are a bunch of items in \"Ready for \nCommitter\" state. Committers: please help with those.\n\n... |
[
{
"msg_contents": "Hello,\nI try to write my first patch. It is too early to tell more about it, \nbut I am just fiddling around with some prototypes.\n\nCan someone tell me, how I can compare two datum fields, when I do not \nknow the data type in advance inside an executor function?\n\nFor example, \"x less t... |
[
{
"msg_contents": "I earliest reference I found to this issue is here\n<http://postgresql.nabble.com/set-search-path-in-dump-output-considered-harm\nful-td1947594.html> and refers to the search_path being arbitrarily set in\nthe file created by pg_dump. This is apparently still the case in 9.4.\n\n \n\nI found... |
[
{
"msg_contents": "Hi,\n\nwhile doing regular builds via buildroot autobuilders\na compile problem for sparc 32bit v8 was found.\nIt seems the defines for Linux are other than for Solaris.\n\nFollowing patch fixes it for buildroot:\n\nThe gcc predefines for Linux are __sparc_v8__/__sparc_v7__\n\nSigned-off-by: ... |
[
{
"msg_contents": "Attached patch fixes oversights converting buf_id to Buffer in\nPrintBufferDescs() and InvalidateBuffer(). Especially for the latter,\nthe reason we haven't seen any reports of the issue might be that it\nneeds certain concurrent conditions to be true.\n\nAlong the line, it also changes all d... |
[
{
"msg_contents": "Today I encountered an interesting situation.\n\n1) A streaming replication primary server and a standby server is\n running. At this point max_connections = 100 on both servers.\n\n2) Shutdown both servers.\n\n3) Change max_connections to 1100 on both servers and restart both\n servers.\... |
[
{
"msg_contents": "I built an index on a jsonb column of a table with RLS enabled but it\nwas not being used. Turns out the the function jsonb_contains needed\nto be LEAKPROOF (thanks Joe Conway). However I do not actually know if\njsonb_contains is LEAKPROOF. Who's responsibility is it to insure\nfunctions are... |
[
{
"msg_contents": "When reviewing some recent patches, I decided the statistics gathered for\narrays had some pre-existing shortcomings.\n\nThe main one is that when the arrays contain rare elements there is no\nhistogram to fall back upon when the MCE array is empty, the way there is\nfor scalar stats. So it ... |
[
{
"msg_contents": "Hi,\n\n#define GinPageIsLeaf(page) ( GinPageGetOpaque(page)->flags & GIN_LEAF )\n#define GinPageIsData(page) ( GinPageGetOpaque(page)->flags & GIN_DATA )\n#define GinPageIsList(page) ( GinPageGetOpaque(page)->flags & GIN_LIST )\n...\n\nThese macros don't actually return a boolean tha... |
[
{
"msg_contents": "Probably since 1bc90f7a (shame on me) pgbench does not report skipped \ntransactions (-L) counts properly: data are not aggregated over all \nthreads as they should be, either under --progress or in the end of run \nreport.\n\nThe attached patch fixes these regressions.\n\n-- \nFabien.\n\n\n-... |
[
{
"msg_contents": "Hi,\n\nWe have a bunch of callbacks that use old-style C function\ndeclarations. I.e. functions with empty parens allowing all types of\ndata being passed:\n\nE.g.\nextern bool expression_tree_walker(Node *node, bool (*walker) (),\n void *context);\nextern No... |
[
{
"msg_contents": "Greetings,\n\nI had a discussion on IRC today with RhodiumToad regarding optimizing a\nspecific query. We didn't manage to figure out how to get postgres to hit a\nGIST index.\n\nThe bigger picture is that I am trying to do some bioinformatics and\nthought that postgres would be a great way o... |
[
{
"msg_contents": "When a user backend (as opposed to vacuum or autoanalyze) gets burdened\nwith cleaning up the GIN pending list, it does not\ncall CHECK_FOR_INTERRUPTS().\n\nSince cleaning does a lot of random IO, it can take a long time and it is\nnot nice to be uninterruptable.\n\nThe attached patch adds an... |
[
{
"msg_contents": "Hi all,\n\nTransactionIdGetCommitTsData@commit_ts.c does the following:\n if (ts)\n *ts = entry.time;\n [...]\n return *ts != 0;\nThis is a bad idea, because if TransactionIdGetCommitTsData is called\nwith ts == NULL this would simply crash. It seems to me that it makes\nlittl... |
[
{
"msg_contents": "Hi,\n\nForcing our bool to be stdbool.h shows up a bunch of errors and\nwarnings:\n\n1) gin stores/queries some bools as GinTernaryValue.\n\n Part of this is easy to fix, just adjust GinScanKeyData->entryRes to\n be a GinTernaryValue (it's actually is compared against MAYBE).\n\n What I... |
[
{
"msg_contents": "Hi,\n\nI'd like to suggest $SUBJECT for inclusion in Postgres 9.6. I'm sure \neveryone would've found it useful at some point in their lives, and the \nfact that it can't be properly implemented in any language other than C \nI think speaks for the fact that we as a project should provide it... |
[
{
"msg_contents": "Close some holes in BRIN page assignment\n\nIn some corner cases, it is possible for the BRIN index relation to be\nextended by brin_getinsertbuffer but the new page not be used\nimmediately for anything by its callers; when this happens, the page is\ninitialized and the FSM is updated (by br... |
[
{
"msg_contents": "I've written a function which allows users to clean up the pending list.\nIt takes the index name and returns the number of pending list pages\ndeleted.\n\n# select * from gin_clean_pending_list('foo_text_array_idx');\n gin_clean_pending_list\n------------------------\n 278... |
[
{
"msg_contents": "Hello,\n\nI am working on a project which requires going through each field inside a\ntuple without using postgresql. I have managed to iterate through each\ntuple inside a table by recycling postgres's code. However, for the part of\nparsing through each field in the tuple, I am not able to ... |
[
{
"msg_contents": "(Please read this message on wide display)\n\nOur team recently tries to run TPC-DS benchmark to know capability of\nPostgreSQL towards typical analytic queries.\nTPC-DS defines about 100 complicated queries. We noticed optimizer made\nunreasonable execution plan towards some of queries.\n\nH... |
[
{
"msg_contents": "Views created by UNION ALL could be updated with both UPDATE and\nDELETE operations. They are just transformed to UPDATE/DELETE\noperation on base tables (or views). I think INSERT cannot be accepted\nhowever. For example, suppose we have v1:\n\nCREATE VIEW v1 AS SELECT * FROM t1 UNION ALL S... |
[
{
"msg_contents": "Hi all,\n\nI saw the email about the idea from KaiGai-san[1],\nand I worked to implement this idea.\n\nNow, I have implemented a part of this idea,\nso I want to propose this feature.\n\nPatch attached just shows my concept of this feature.\nIt works fine for EXPLAIN, but it returns wrong res... |
[
{
"msg_contents": "> On Fri, Aug 7, 2015 at 2:15 PM, Kouhei Kaigai <kaigai@ak.jp.nec.com> wrote:\r\n> >\r\n> > > On Sat, Aug 1, 2015 at 6:39 PM, Kouhei Kaigai <kaigai@ak.jp.nec.com> wrote:\r\n> > > >\r\n> >\r\n> > > > > > If we pull Funnel here, I think the plan shall be as follows:\r\n> > > > > > Funnel\r\n>... |
[
{
"msg_contents": "Re-add BRIN isolation test\n\nThis time, instead of using a core isolation test, put it on its own\ntest module; this way it can require the pageinspect module to be\npresent before running.\n\nThe module's Makefile is loosely modeled after test_decoding's, so that\nit's easy to add further t... |
[
{
"msg_contents": "So I added the brin isolation test back. Because it needs the\npageinspect module, it can only work under \"make check\", not\ninstallcheck. The problem is that this means buildfarm will not run it,\nbecause it only runs installcheck :-(\n\nI realized that the important modules that run und... |
[
{
"msg_contents": "This is regarding supporting of multi-tenancy in a single PostgreSQL instance\nusing the row level security feature. The main idea is to have the\n\"row level security\"\nenabled on system catalog tables, thus the user can get only the rows that are\neither system objects or the user objects,... |
[
{
"msg_contents": "Hi,\n\nwhen building with optimizations clang-3.7, probably some older\ncompilers as well, fail with a funny error:\n\nfatal error: error in backend: Cannot select: intrinsic %llvm.x86.sse42.crc32.64.64\n\nturns out that is because configure chose to use the crc32 instruction,\nwithout the ac... |
[
{
"msg_contents": "Hello Everyone,\n\nI have a problem related to query in PostgreSQL.Some queries are not running.Please help me to find out a solution.\n\nThanks \nRahul\n=====-----=====-----=====\nNotice: The information contained in this e-mail\nmessage and/or attachments to it may contain \nconfidential or... |
[
{
"msg_contents": "On 08/14/2015 12:20 PM, Andres Freund wrote:\n> Hi,\n>\n> when building with optimizations clang-3.7, probably some older\n> compilers as well, fail with a funny error:\n>\n> fatal error: error in backend: Cannot select: intrinsic %llvm.x86.sse42.crc32.64.64\n>\n> turns out that is because co... |
[
{
"msg_contents": "I had the idea that it would be useful to have some regression tests\nthat verify that the deadlock checker works as advertised, because we\ncurrently have just about zero test coverage for it. And it's easy\nenough to write a regression test that causes a simple 2-way deadlock.\nBut you can... |
[
{
"msg_contents": "Hello, I want to write a \"BackgroundWorker\" in C++ (have lots of C++ \ncode and libs to reuse).\n\nI found \" 35.9.13 Using C++ for Extensibility \" in the 9.3/4 \ndocumentation who says it's possible and gives some guidelines for \nsource-code writing.\nCompiling is not too difficult if ... |
[
{
"msg_contents": "In commit 0fc94a5ba I wrote:\n\n+ * ... It's okay to update the [ session-wide ]\n+ * hash table with the new tree because all plpgsql functions within a\n+ * given transaction share the same simple_eval_estate.\n\nUm. Well, that's true for actual functions, but plpgsql DO blocks us... |
[
{
"msg_contents": "Hi, I'm working on a FDW for the unix/linux user database - think\n/etc/passwd and /etc/group although I'm actually using system calls that\ncould be quietly redirected to LDAP or other backends. It's easy to create\nthe FDW and a table associated with it, something like\n\nCREATE TABLE passw... |
[
{
"msg_contents": "Commit f14a6bbedb79adce2298d0d4f5e2abe8563e0eca added an isolation\ntest, alter-table-1.spec, which reads in part:\n\nsession \"s2\"\nsetup { BEGIN; }\nstep \"rx1\" { SELECT * FROM b WHERE a_id = 1 LIMIT 1; }\nstep \"wx\" { INSERT INTO b VALUES (0); }\nstep \"rx1\" {... |
[
{
"msg_contents": "Hello hackers,\n\n* Description\n\nThis patch is a proposal to allow the use of word 'semester' to\nextract it from date in functions like EXTRACT, DATE_PART, etc and\nadds the letter 'S' to format the date output in to_char.\n\n** Example\n\nSELECT EXTRACT(semester FROM DATE '2015-07-07');\n... |
[
{
"msg_contents": "Attached is a small patch which improves the way get_base_rel_indexes()\nworks.\n\nThe current version creates a new bitmapset on each recursion level then\nbms_joins() to the one on the next level up each time. I understand that\nthis will patch will have about a 0 net performance improvemen... |
[
{
"msg_contents": "Hi,\n\nThe attached patch adds support for RADIUS passwords longer than 16 octets.\n\n\n.m\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)\nTo make changes to your subscription:\nhttp://www.postgresql.org/mailpref/pgsql-hackers",
"msg_date": "Sat, 15 Aug 201... |
[
{
"msg_contents": "When ginbulkdelete gets called for the first time in a VACUUM(i.e. stats\n== NULL), one of the first things it does is call ginInsertCleanup to get\nrid of the pending list. It does this in lieu of vacuuming the pending\nlist.\n\nThis is important because if there are any dead tids still in... |
[
{
"msg_contents": "Hi,\n\nThere seems to be a bug in the make rules when DTrace is enabled. It\ncauses dtrace -G to be invoked twice when building PostgreSQL as a\nFreeBSD port: once during the build itself, and once during\ninstallation. For a long time this has been worked around on FreeBSD\nwith a change to ... |
[
{
"msg_contents": "Calling CONTINUE with a label that's not a loop produces an error \nmessage with no context info [1]. This is because of\n\n\trc = exec_stmt_block(&estate, func->action);\n\tif (rc != PLPGSQL_RC_RETURN)\n\t{\n\t\testate.err_stmt = NULL;\n\t\testate.err_text = NULL;\n\nI trawled through git bl... |
[
{
"msg_contents": "spi_printtup() has the following code (spi.c:1798):\n\n if (tuptable->free == 0)\n {\n tuptable->free = 256;\n tuptable->alloced += tuptable->free;\n tuptable->vals = (HeapTuple *) repalloc(tuptable->vals,\n\n tuptable->alloced * si... |
[
{
"msg_contents": "Hi all,I throught I would try sqlsmith with more sanitizers. So, I tried the ThreadSanitizer. Building off HEAD (522400a5198f63823406202e18fdaf3621619d98), it fails to complete the thread check since the thread test because there are some volatile ints being accessed between threads[1]. Volat... |
[
{
"msg_contents": "I'm starting to work on a tar FDW as a proxy for a much more specific FDW.\n(It's the 'faster to build two and toss the first away' approach - tar lets\nme get the FDW stuff nailed down before attacking the more complex\ncontainer.) It could also be useful in its own right, or as the basis fo... |
[
{
"msg_contents": "Folks,\n\nIn the interest of consistency, which is to say, of not hitting\nbarriers that are essentially implementation details, I'd like to\npropose that we allow the rest of the row-returning commands inside\nWITH clauses. We currently have:\n\nSELECT\nVALUES\nINSERT/UPDATE/DELETE ... RETU... |
[
{
"msg_contents": "Hi,\n\nSome time ago the array-style subscripting for the jsonb data type was\ndiscussed in this mailing list. I think it will be quite convenient to have\na such nice syntax to update jsonb objects, so I'm trying to implement\nthis. I created a patch, that allows doing something like this:\n... |
[
{
"msg_contents": "The commit message for de76884 contains some important information about\nthe purpose and use of the new .partial WAL files. But I don't see\nanything about this in the documentation or another user-visible place.\n We should probably add something.\n\n\n-- \nSent via pgsql-hackers mailing l... |
[
{
"msg_contents": "Hi,\n\nWhen tab-completing after GRANT EXECUTE, currently psql injects\n\"PROCEDURE\", rather than the expected \"ON\".\n\nThe code for completing with \"ON\" is there, but it's not reached due to\nfalling earlier into another branch, one that handles CREATE TRIGGER.\n\nA trivial patch is att... |
[
{
"msg_contents": "Rationale\n=========\n\nSince introduction of the WAL-based replication into the PostgreSQL, it is\npossible to create high-availability and load-balancing clusters.\n\nHowever, there is no support for failover in the client libraries. So, only\nway to provide transparent for client applicati... |
[
{
"msg_contents": "Hi,\n\nI would like propose $SUBJECT for this development cycle. Attached is a\nWIP patch that implements most if not all of what's described below. Some\nyet unaddressed parts are mentioned below, too. I'll add this to the CF-SEP.\n\nSyntax\n======\n\n1. Creating a partitioned table\n\nCREAT... |
[
{
"msg_contents": "In [1], it was discussed to make wal_level changeable at run time\n(PGC_SIGHUP), as part of an effort to make replication easier to set up\nand/or provide better defaults. I was wondering what it would take to\ndo that.\n\nI looks like increasing the setting is doable, as long as we WAL-log ... |
[
{
"msg_contents": "Hello,\n\nI noticed ExecChooseHashTableSize() in nodeHash.c got failed by\nAssert(nbuckets > 0), when crazy number of rows are expected.\n\nBACKTRACE:\n\n#0 0x0000003f79432625 in raise () from /lib64/libc.so.6\n#1 0x0000003f79433e05 in abort () from /lib64/libc.so.6\n#2 0x000000000092600a ... |
[
{
"msg_contents": "Hi,\n\nI was looking at PL/pgSQL documentation and realized that contrary to\nspec, I've been omitting the colon ':' from assignments, e.g. writing\n\n 'x = 5' rather than the correct\n 'x := 5'\n\nI don't see any error messages about this.\n\nI am not aware of any problems due to this. ... |
[
{
"msg_contents": "Hi hackers, I've been wrestling with this one for a while and gone\ndown a couple blind alleys, so time to ask the experts.\n\nPostGIS has a couple things different from the extensions that live in contrib,\n\n- it has some GUCs\n- it has a versioned loadable library (postgis-2.1.so, postgis-... |
[
{
"msg_contents": "pg_upgrade's check.c contains a function called\ncheck_for_isn_and_int8_passing_mismatch. If the float8 pass-by-value\nvalues differ between the old and new clusters, which is likely to\nhappen on Windows 64 because of cf376a4ad, and if the old cluster\ncontains any databases which contain f... |
[
{
"msg_contents": "When we check a tuple for MVCC, it has to pass checks that the inserting\ntransaction has committed, and that it committed before our snapshot\nbegan. And similarly that the deleting transaction hasn't committed, or\ndid so after our snapshot.\n\nXidInMVCCSnapshot is (or can be) very much ch... |
[
{
"msg_contents": "> On Mon, Aug 17, 2015 at 6:40 AM, Kouhei Kaigai <kaigai@ak.jp.nec.com> wrote:\r\n> > Here is one other thing I could learn from TPC-DS benchmark.\r\n> >\r\n> > The attached query is Q4 of TPC-DS, and its result was towards SF=100.\r\n> > It took long time to compete (about 30min), please see... |
[
{
"msg_contents": "Hi\n\nI miss a functionality that helps with parsing any identifier to basic\nthree parts - database, schema, objectname. We have this function\ninternally, but it is not available for SQL layer.\n\nFUNCTION parse_ident(IN ident text, OUT dbname text, OUT schemaname text,\nOUT objectname text... |
[
{
"msg_contents": "Hello,\n\nI miss the newer features xpath_table equivalent in xml2. Are you planning\nto replace it with something?\n\n \n\nThank's\n\n \n\n \n\nMichal \n\n \n\n\n\n\nIng. Michal Šalko\nSQL specialista, vývojář\n\n+420 549 494 572 \n <mailto:salko@iba.muni.cz> salko@iba.muni.cz\nMasarykova un... |
[
{
"msg_contents": "I would like to execute a trigger function (written in C) in one of my\nbackground workers.\n\nDidn't figure out how to do that not even if it's possible.\n\nCurrently my trigger function is called, but in the \"server-process\"\nconnected to the client who does the \"insert into ...\" .\n\nA... |
[
{
"msg_contents": "I looked into the crash reported in bug #13579. The proximate cause\nof the crash is that PLyString_ToComposite does this:\n\n PLy_output_datum_func2(&info->out.d, typeTup,\n exec_ctx->curr_proc->langid,\n exec_ctx->curr_proc->trftypes);\n\... |
[
{
"msg_contents": "Hi,\n\nWe use RADIUS authentication at $WORK, and it has one major flaw (well, \ntwo, but I already fixed the other one this week): it only supports \nspecifying a single server, which as we might know, is bad for high \navailability. So I'm developing a patch to fix this issue, but I'm not ... |
[
{
"msg_contents": "> On Mon, Aug 17, 2015 at 9:40 AM, Kouhei Kaigai <kaigai@ak.jp.nec.com> wrote:\r\n> > I think SortSupport logic provides a reasonable way to solve this\r\n> > kind of problem. For example, btint4sortsupport() informs a function\r\n> > pointer of the fast version of comparator (btint4fastcmp) ... |
[
{
"msg_contents": "I'll start a new thread for this, since my external sorting patch has\nnow evolved well past the original \"quicksort with spillover\"\nidea...although not quite how I anticipated it would. It seems like\nI've reached a good point to get some feedback.\n\nI attach a patch series featuring a n... |
[
{
"msg_contents": "Is there any significant interest in either of these?\n\nJosh Berkus tells me that he would like pg_controldata information, and \nI was a bit interested in pg_config information, for this reason: I had \na report of someone who had configured using --with-libxml but the xml \ntests actually ... |
[
{
"msg_contents": "Hi all!\n\n\nWe just had a case of a very long running process of ours that creates \ndoes a lot of prepared statements through Perls DBD:Pg running into:\n\nhttps://rt.cpan.org/Public/Bug/Display.html?id=88827\n\nThis resulted in millions of prepared statements created, but not \nremoved in ... |
[
{
"msg_contents": "Hi,\nNormally I try to annotate incoming queries, to make it easier to diagnose\nslow ones. For example:\n\n-- Users.findByPhoneNumber\nSELECT * FROM ....\n\nThe pg_dump and pg_restore commands issue a COPY with no possibility of\nadding a comment. It would be useful to know who or what exact... |
[
{
"msg_contents": "I don't see any reason not to remove this. It's been unused since\na191a169d6d0b9558da4519e66510c4540204a51, dated Jan 10 2007.\n\n-- \n�lvaro Herrera Pe�alol�n, Chile\n\"La realidad se compone de muchos sue�os, todos ellos diferentes,\npero en cierto aspecto, parecidos...\" (Y... |
[
{
"msg_contents": "I split this into a new thread to talk about archiving best practices.\n\nOn 8/18/15 2:25 PM, Stephen Frost wrote:\n> * Stephen Frost (sfrost@snowman.net) wrote:\n>> * Robert Haas (robertmhaas@gmail.com) wrote:\n>>> On Mon, Aug 17, 2015 at 2:50 PM, Peter Eisentraut <peter_e@gmx.net>\nwrote:\n... |
[
{
"msg_contents": "Hello,\n\nduring my testing I've found cases of left-shifting negative integers \nduring run-time and I was recently encouraged to post a report of them, \nso here it is (done against 960ea971e66bcd621ba88841b4cb85c7f0e7c383).\n\nBack-traces are included in the attached file. If any kind of \... |
[
{
"msg_contents": "diff --git a/src/backend/commands/trigger.c b/src/backend/commands/trigger.c\nindex d169027..43421d6 100644\n--- a/src/backend/commands/trigger.c\n+++ b/src/backend/commands/trigger.c\n@@ -4126,7 +4126,7 @@ AfterTriggerEndXact(bool isCommit)\n\n\n /*\n- * Forget the query stack and cons... |
[
{
"msg_contents": "It is not easy to compare events on a pgbench runs (oops, the tps is down) \nwith for instance events in postgres log, so as to figure out what may \nhave cause a given glitch.\n\nThis patches adds an option to replace the \"time since pgbench run \nstarted\" with a timestamp in the progress ... |
[
{
"msg_contents": "Hello,\nTried this a few times. I am trying to compile and run PostgreSQL 9.4.0 on\nAIX 7.1. I was able to compile with following settings:\nCC=\"xlc_r -q64 -qnoansialias\"\nCFLAGS=\"-g -O0\"\nAR=\"ar -X64\"\nOBJECT_MODE=64\n./configure --enable-cassert --enable-debug\n-with-includes=/opt/f... |
[
{
"msg_contents": "Hi\n\nI found so a set \"psql\" and \"xargs\" is pretty strong. But I miss a psql\noption for simple returning current database and continuing in pipeline.\n\nWhat I am doing:\n\npsql postgres -At -c \"select datname from pg_database\" |\nxargs -P 3 -I % psql % -At -c \"select current_databe(... |
[
{
"msg_contents": "Just checking to see if you guys have settled on a date for 9.5.0 release.\n\nThe PostGIS Dev team would like to release PostGIS 2.2 about or a week or\nmore before, but not too far ahead of 9.5.0 release.\n\n\nThanks,\nRegina Obe\n\n\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hack... |
[
{
"msg_contents": "-----BEGIN PGP SIGNED MESSAGE-----\nHash: SHA1\n\nDo we care that as of 9.5 pg_controldata output is not 100% aligned\nanymore? The culprit is:\n\n Current track_commit_timestamp setting: off\n\nIts value is shifted 2 characters to the right with respect to all the\nothers. I think it ought ... |
[
{
"msg_contents": "Hi,\n\n From the Debian ports buildd:\n\nhttps://buildd.debian.org/status/fetch.php?pkg=postgresql-9.4&arch=alpha&ver=9.4.4-1&stamp=1434132509\n\nmake[5]: Entering directory '/�PKGBUILDDIR�/build/src/backend/postmaster'\n[...]\ngcc -Wall -Wmissing-prototypes -Wpointer-arith -Wdeclaration-... |
[
{
"msg_contents": "(sending again, forgot to cc hackers, sorry for the duplicate)\n\nHi,\n\nI'm trying to use the custom scan API to replace code that currently\ndoes everything via hooks and isn't safe against copyObject() (Yes,\nthat's not a grand plan).\n\nTo me dealing with CustomScan->custom_private seems ... |
[
{
"msg_contents": "Hello,\n\nCan the t_len field in HeapTuple structure be used to verify the length of\nthe tuple?\n\nThat is, if I calculate the length from the contents of the tuple using\ndata from pg_attribute for fixed length fields and the data from the header\nfor varlena fields, should it always match ... |
[
{
"msg_contents": "This works:\n\nCREATE TYPE c AS (r float, i float);\nCREATE FUNCTION mag(c c) RETURNS float LANGUAGE sql AS $$\nSELECT sqrt(c.r^2 + c.i^2)\n$$;\nSELECT mag( (2.2, 2.2) );\n mag\n------------------\n 3.11126983722081\n\nBut this doesn't:\nCREATE FUNCTION magsum( c c[] ) RETURNS float L... |
[
{
"msg_contents": "Hi all,\n\nThe following commit has broken the SSL test suite (embarrassing and\nlonely moment):\ncommit 13d856e177e69083f543d6383eeda9e12ce3c55c\nAuthor: Heikki Linnakangas <heikki.linnakangas@iki.fi>\nDate: Wed Jul 29 19:17:02 2015 +0300\n\nMake TAP tests work on Windows.\n[...]\n*Michael... |
[
{
"msg_contents": "Hi\n\n if (options.single_txn && options.action != ACT_FILE &&\noptions.action == ACT_NOTHING)\n {\n fprintf(stderr, _(\"%s: -1 can only be used in\nnon-interactive mode\\n\"), pset.progname);\n exit(EXIT_FAILURE);\n }\n\nthe expression shoul... |
[
{
"msg_contents": "Hi all,\n\nAs of now, file access functions in genfile.c can only be used by\nsuperusers. This proposal is to relax those functions so as\nreplication users can use them as well. Here are the functions aimed\nby this patch:\n- pg_stat_file\n- pg_read_binary_file\n- pg_read_file\n- pg_ls_dir\n... |
[
{
"msg_contents": "Hi,\n\nThe locking around rowsecurity policy expressions seems to be\ninsufficient:\nSELECT * FROM document WHERE f_leak(dtitle) ORDER BY did;\nWARNING: RelationIdGetRelation(247984) without holding lock on the relation\nWARNING: relation_open(247984, NoLock) of relation \"uaccount\" withou... |
[
{
"msg_contents": "Hi,\n\nI searched the current code, all diffs to the current code, and the\nmailing list, but still haven't got an actual clue what RIR is supposed\nto stand for. There's a few things that come to mind (Rewrite Instead\nRule?), but none of them seem to make too much sense.\n\nGreetings,\n\nAn... |
[
{
"msg_contents": "In ResolveRecoveryConflictWithLock, there is the comment:\n\n /*\n * If blowing away everybody with conflicting locks doesn't work, after\n * the first two attempts then we just start blowing everybody away\nuntil\n * it does work.\n\n\nBut what it does is something different t... |
[
{
"msg_contents": "I don't have an independent reproduction yet (though make test in [1] \nshould reproduce this). I haven't actually been able to reproduce by \nhand yet, but pgtap has something to do with this. This is affecting at \nleast 9.4 and a fairly recent HEAD.\n\n\n-- Bits from top of test/sql/base.s... |
[
{
"msg_contents": "Is it intentional that pg_extension_config_dump() doesn't also add \nsequences owned by a table? If not, I'll work on a patch.\n-- \nJim Nasby, Data Architect, Blue Treble Consulting, Austin TX\nExperts in Analytics, Data Architecture and PostgreSQL\nData in Trouble? Get it in Treble! http://... |
[
{
"msg_contents": "Hi,\nthis is a patch for src/tools/version_stamp.pl that adds the current Git \ncommit information from \"git describe --tags --long\" to the current \nversion string if \"git\" is specified on the command line. I've been \ntesting for regressions and such lately (none found, yay), and the \n... |
[
{
"msg_contents": "Hello, this patch enables planner to be couscious of inter-column\ncorrelation.\n\nSometimes two or more columns in a table has some correlation\nwhich brings underestimate, which leads to wrong join method and\nends with slow execution.\n\nTomas Vondra is now working on heavily-equipped mult... |
[
{
"msg_contents": "Hi, this is a spin-off patch from Fabien COELHO's\nbackslash-continuations.\n\nThe major concept of this patch is making usage of psql's scanner\nto get rid of home-grown scanner of pgbench to make\nmulti-statement feature available for pgbench custom scripts.\n\nThis patch does the following... |
[
{
"msg_contents": "Hello,\n\nI added a \"NOFITY chan\" to the SQL arg of an SPI_execute(), (I did it\nalso with just the NOTIFY statement),\nbut the listeners (other workers) don't get the notification until a\n\"NOTIFY chan\" is done for example with pgadmin,\n\nThey don't get lost, just not emited after the \... |
[
{
"msg_contents": "Hello Hackers\n\nHow would you react if I provided a patch which introduces a CMake build \nsystem?\n\nOld thread:\nhttp://www.postgresql.org/message-id/200812291325.13354.peter_e@gmx.net\n\nThe main argument against the \"it's too hard\". I'm right?\n\nThanks!\n-- \nYUriy Zhuravlev\nPostgres... |
[
{
"msg_contents": "Hello,\nI'm going to create two factor authentication for pgadmin server...\nI'm using postgresql 9.4 with pgadmin III on Linux Mint 17.2 32bit...\nI already have 1 password authentication but For better security, I just\nwant to force 2 of them. The authentication factors could be any\nthing... |
[
{
"msg_contents": "Hi,\n\nThis is a reboot of my previous proposal for pivoting results in psql,\nwith a new patch that generalizes the idea further through a command\nnow named \\rotate, and some examples.\n\nSo the concept is: having an existing query in the query buffer,\nthe user can specify two column numb... |
[
{
"msg_contents": "Hi,\n\nIn pg_upgrade, how about adding a feature to copy data directory over\nnetwork.\nThat is, we can run pg_upgrade from our new host, where old host will be a\nremote machine.\nWe can add two parameters - oldhost and if it is used, pg_upgrade will\nidentify the old host as remote and inst... |
[
{
"msg_contents": "Hi\r\n\r\ncurrently JSON support NULL value - but we doesn't convert NULL to JSON\r\ncorrectly\r\n\r\npostgres=# select to_json(NULL::text) IS NULL;\r\n┌──────────┐\r\n│ ?column? │\r\n╞══════════╡\r\n│ t │\r\n└──────────┘\r\n(1 row)\r\n\r\nprobably should be json \"null\";\r\n\r\nlike\... |
[
{
"msg_contents": "Hello,\n\nThe other day I've rediscovered the exciting idea of using signals to dump\na backend's currently executed query plan, which, it turns out, was already\nproposed by Pavel and Simon in these threads:\n\nhttp://www.postgresql.org/message-id/flat/CAFj8pRA-DuzkmDtu52CiUgb0P7TVri_B8LtjMJ... |
[
{
"msg_contents": "The buffer/README section on buffer clean up locks never got updated for\nthe creation of Heap Only Tuples and their associated compaction logic.\n\nI've attached a patch to change the explanation. I'm sure someone can word\nit better than I have.\n\nCheers,\n\nJeff\n\nThe buffer/README sect... |
[
{
"msg_contents": "I have recently increased my public statements about the idea of adding\nhorizontal scaling/sharding to Postgres. I wanted to share with hackers\na timeline of how we got here, and where I think we are going in the\nshort term:\n\n2012-2013: As part of writing my scaling talk\n(http://momjia... |
[
{
"msg_contents": "Discovered when debugging libpqtypes test failures:\n\nhttps://bugs.debian.org/cgi-bin/bugreport.cgi?bug=795729\n\npostgres =# set timezone = 'Etc/UTC+1';\nSET\npostgres =# set datestyle = 'postgres';\nSET\npostgres =# select '2015-01-01 01:00:00 +0100'::timestamptz;\n Wed 31 Dec 23:00:00 201... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.