wrote:\\n> Hi,\\n>\\n> On 2016-08-04 16:29:09 +0530, Pavan Deolasee wrote:\\n>> Indexes whose values do not change do not require new index pointers. Only\\n>> the index whose key is being changed will need a new index entry. The new\\n>> index entry will be set to the CTID of the root line pointer.\\n>\\n> That seems to require tracing all hot-chains in a page, to actually\\n> figure out what the root line pointer of a warm-updated HOT tuple is,\\n> provided it's HOT_UPDATED itself. Or have you found a smart way to\\n> figure that out?\\n\\nHmm, sorry, I did think of that point and I thought I had added it to the doc.\\n\\nSo, yes, I agree - re-locating the root is the biggest downside to\\nthis idea. Perhaps Pavan has other thoughts?\\n\\nI think its doable, but it will be fiddly.\\n\\n-- \\nSimon Riggs 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, 4 Aug 2016 18:11:17 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 09:58:29AM -0700, Andres Freund wrote:\\n> On 2016-08-04 12:55:25 -0400, Bruce Momjian wrote:\\n> > On Thu, Aug 4, 2016 at 09:31:18AM -0700, Andres Freund wrote:\\n> > > Hi,\\n> > > \\n> > > On 2016-08-04 16:29:09 +0530, Pavan Deolasee wrote:\\n> > > > Indexes whose values do not change do not require new index pointers. Only\\n> > > > the index whose key is being changed will need a new index entry. The new\\n> > > > index entry will be set to the CTID of the root line pointer.\\n> > > \\n> > > That seems to require tracing all hot-chains in a page, to actually\\n> > > figure out what the root line pointer of a warm-updated HOT tuple is,\\n> > > provided it's HOT_UPDATED itself. Or have you found a smart way to\\n> > > figure that out?\\n> > \\n> > The index points to the head of the HOT chain, and you just walk the\\n> > chain on the page --- on need to look at other chains on the page.\\n> \\n> When doing an update, you'll need to re-find the root tuple, to insert\\n> the root ctid for the new index tuples.\\n\\nAh, I had not thought of that --- good point.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 4 Aug 2016 13:12:23 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 7:59 AM, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:\\n> We don’t want to force a recheck for every index fetch because that will\\n> slow everything down. So we would like a simple and efficient way of knowing\\n> about the existence of a WARM tuple in a chain and do a recheck in only\\n> those cases, ideally O(1). Having a HOT chain contain a WARM tuple is\\n> discussed below as being a “WARM chain”, implying it needs re-check.\\n>\\n> We could solve this by either 1) marking both old and new index tuples as\\n> \\\"recheck-required\\\" or 2) marking the HOT chain on the heap as\\n> \\\"recheck-required\\\" such that any tuple returned from the chain requires a\\n> recheck.\\n>\\n> The advantage of doing 1) is that the recheck is required only for the\\n> compromised index.\\n> Note that in presence of multiple index keys pointing to the same root line\\n> pointer, the chain needs re-check for both the old as well as the new index\\n> key. The old index key must not fetch the new tuple(s) and the new index key\\n> must not fetch the old tuple(s). So irrespective of whether an old or a new\\n> tuple is being returned, the caller must know about the WARM tuples in the\\n> chains. So marking the index would require us to mark both old and new index\\n> tuples as requiring re-check. That requires an additional index scan to\\n> locate the old row and then an additional write to force it to re-check,\\n> which is algorithmically O(NlogN) on table size.\\n>\\n> Marking the heap, (2) is O(1) per updated index, so seems better. But since\\n> we don't know with respect to which index or indexes the chain is broken,\\n> all index scans must do a recheck for a tuple returned from a WARM chain.\\n>\\n> How do we mark a chain as WARM? How do we clear the flag? There are a few\\n> possible approaches:\\n>\\n> 1. Mark the first WARM tuple which causes HOT chain to become WARM with a\\n> special HEAP_RECHECK_REQUIRED flag (this flag must then be carried over to\\n> any further additions to the chain. Then whenever a tuple if returned from a\\n> chain, we must look forward into the chain for WARM tuple and let the caller\\n> know about potential breakage. This seems simple but would require us to\\n> follow HOT chain every time to check if it’s HOT or WARM.\\n>\\n> 2. Mark the root line pointer (or the root tuple) with a special\\n> HEAP_RECHECK_REQUIRED flag to tell us about the presence of a WARM tuple in\\n> the chain. Since all indexes point to the root line pointer, it should be\\n> enough to just mark the root line pointer (or tuple) with this flag.\\n>\\n> 3. We could also adopt a hybrid approach and mark the new index tuple and\\n> new heap tuple with HEAP_RECHECK_REQUIRED flag and presence of either of the\\n> flag in either tuple forces recheck.\\n\\n\\nI've actually been thinking of another possibility in the context of\\nLITE, and what I was pondering looks eerily similar to WARM, so let me\\nsummarize (I was going to write a lengthier POC but I thought I better\\ncomment now since you're introducing the same concept):\\n\\nMarks are troublesome becuase, as you mention, you would need one\\n\\\"WARM\\\" bit per index to be efficient. We also don't want a recheck on\\nevery index access.\\n\\nHOT is very close to WARM already, even the code. The only problem\\nwith HOT is that it stops scanning the update chain when a tuple is\\nnot HOT-updated. If heap_hot_search_buffer knew to keep on following\\nthe update chain when there is a WARM update on the index in question,\\nthis could work.\\n\\nBut it won't work if it's implemented naively, because if there was\\nanother item pointer in another page of the index pointing to a heap\\ntuple that belongs to an already-visited chain, which is possible in\\nthe below case, then the scan would produce duplicate rows:\\n\\nN: Row versions:\\n->: update\\n* : causes a new index tuple on index I\\n\\n1 -> 2 -> 3 -> 4 -> 5\\n* * *\\na b a <- key\\n\\nIf the scan qual is \\\"key in ('a','b')\\\", then the index scan will visit\\nboth versions of the row, 1, 3 and 4. Suppose only 5 is visible, and\\nsuppose the whole chain lies in the same page.\\n\\nThere is one update chain, 1..5, but three WARM chains: 1..2, 3, 4..5\\n\\nWhen visiting item pointers, 1 will be found, the chain will be\\nfollowed and eventually version 5 will pass the visibility check and\\nthe tuple will pass the scan quals, it will even match the key in the\\nindex item, so no key check will fix this. 5 will be yielded when\\nvisiting version 1.\\n\\nNext, version 3 will be visited. There's no easy way to know that we\\nalready visited 3, so we'll follow the chain all the way to 5, and,\\nagain, it will be yielded. Here, the key won't match, so maybe this\\ncase could be filtered out with a key check.\\n\\nFinally, version 4 will be visited, the chain will be followed to 5,\\nand as in the first case, it will be yielded.\\n\\nSo the scan yielded the same heap tuple thrice, which isn't an ideal situation.\\n\\nIt would be totally acceptable for a bitmap index scan, so the\\nexpensive logic I will be outlining below may be skipped when building\\na bitmap (lossy or not).\\n\\nTo fix this, what I was pondering, and I believe it would be viable,\\nis to teach heap_hot_search_buffer about the WARM invariant. It will\\nmake correctness heavily depend on the invariant being true, which\\nmeans either flagging item pointers as WARM chains, or requiring a\\nreindex during upgrade to make sure all indexes verify the invariant -\\nas old indices won't.\\n\\nWhen an item pointer is WARM (either implicit or explicit),\\nheap_hot_search_buffer will only stop following the update chain if it\\nreaches not the end of a HOT chain, but rather a key change. For this,\\nit will need to recheck the key of all but the first TID in the chain,\\nso singleton chains (ie: not-updated or frozen tuples) won't incurr\\nthis extra cost. When walking the chain, it will need to form an index\\ntuple for both the old and new versions, and compare them, and follow\\nthe chain *only* if the keys are equal.\\n\\nAs an optimization, if the tuple is marked HOT-updated, the key check\\nmay be skipped.\\n\\nVacuum will need to be taught not to break the invariant, but I\\nbelieve this is viable and efficient.\\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, 4 Aug 2016 14:14:37 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On 4 August 2016 at 18:05, Bruce Momjian <bruce@momjian.us> wrote:\\n\\n>> Approach 2 seems more reasonable and simple.\\n>>\\n>> There are only 2 bits for lp_flags and all combinations are already used. But\\n>> for LP_REDIRECT root line pointer, we could use the lp_len field to store this\\n>> special flag, which is not used for LP_REDIRECT line pointers. So we are able\\n>> to mark the root line pointer.\\n>\\n> Uh, as I understand it, we only use LP_REDIRECT when we have _removed_\\n> the tuple that the ctid was pointing to, but it seems you would need to\\n> set HEAP_RECHECK_REQUIRED earlier than that.\\n\\nHmm. Mostly there will be one, so this is just for the first update\\nafter any VACUUM.\\n\\nAdding a new linepointer just to hold this seems kludgy and could mean\\nwe run out of linepointers.\\n\\n-- \\nSimon Riggs 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, 4 Aug 2016 18:16:02 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 09:58:29AM -0700, Andres Freund wrote:\\n> On 2016-08-04 12:55:25 -0400, Bruce Momjian wrote:\\n> > On Thu, Aug 4, 2016 at 09:31:18AM -0700, Andres Freund wrote:\\n> > > Hi,\\n> > > \\n> > > On 2016-08-04 16:29:09 +0530, Pavan Deolasee wrote:\\n> > > > Indexes whose values do not change do not require new index pointers. Only\\n> > > > the index whose key is being changed will need a new index entry. The new\\n> > > > index entry will be set to the CTID of the root line pointer.\\n> > > \\n> > > That seems to require tracing all hot-chains in a page, to actually\\n> > > figure out what the root line pointer of a warm-updated HOT tuple is,\\n> > > provided it's HOT_UPDATED itself. Or have you found a smart way to\\n> > > figure that out?\\n> > \\n> > The index points to the head of the HOT chain, and you just walk the\\n> > chain on the page --- on need to look at other chains on the page.\\n> \\n> When doing an update, you'll need to re-find the root tuple, to insert\\n> the root ctid for the new index tuples.\\n\\nAlso, I was thinking we could just point into the middle of the HOT\\nchain to limit the number of rows we have to check, but the problem\\nthere is that HOT pruning could then not remove that middle ctid, which\\nis bad.\\n\\nI wonder if walking all HOT chains on a single page to find the root is\\ncheap enough. The ctid tells you if it is part of a HOT chain, right?\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 4 Aug 2016 13:16:35 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On 2016-08-04 18:11:17 +0100, Simon Riggs wrote:\\n> On 4 August 2016 at 17:31, Andres Freund <andres@anarazel.de> wrote:\\n> > Hi,\\n> >\\n> > On 2016-08-04 16:29:09 +0530, Pavan Deolasee wrote:\\n> >> Indexes whose values do not change do not require new index pointers. Only\\n> >> the index whose key is being changed will need a new index entry. The new\\n> >> index entry will be set to the CTID of the root line pointer.\\n> >\\n> > That seems to require tracing all hot-chains in a page, to actually\\n> > figure out what the root line pointer of a warm-updated HOT tuple is,\\n> > provided it's HOT_UPDATED itself. Or have you found a smart way to\\n> > figure that out?\\n> \\n> Hmm, sorry, I did think of that point and I thought I had added it to the doc.\\n> \\n> So, yes, I agree - re-locating the root is the biggest downside to\\n> this idea. Perhaps Pavan has other thoughts?\\n> \\n> I think its doable, but it will be fiddly.\\n\\nI'm less afraid of the fiddlyness of finding the root tuple, than the\\ncost. It's not cheap to walk through, potentially, all hot chains to\\nfind the root ctid.\\n\\nHave you considered what it'd take to allow index pointers to allow to\\npoint to \\\"intermediate\\\" root tuples? I.e. have some indexes point into\\nthe middle of an update-chain, whereas others still point to the\\nbeginning? There's certainly some complications involved with that, but\\nit'd also have the advantage in reducing the amount of rechecking that\\nneeds to be 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\": \"Thu, 4 Aug 2016 10:17:28 -0700\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On 4 August 2016 at 18:17, Andres Freund <andres@anarazel.de> wrote:\\n> On 2016-08-04 18:11:17 +0100, Simon Riggs wrote:\\n>> On 4 August 2016 at 17:31, Andres Freund <andres@anarazel.de> wrote:\\n>> > Hi,\\n>> >\\n>> > On 2016-08-04 16:29:09 +0530, Pavan Deolasee wrote:\\n>> >> Indexes whose values do not change do not require new index pointers. Only\\n>> >> the index whose key is being changed will need a new index entry. The new\\n>> >> index entry will be set to the CTID of the root line pointer.\\n>> >\\n>> > That seems to require tracing all hot-chains in a page, to actually\\n>> > figure out what the root line pointer of a warm-updated HOT tuple is,\\n>> > provided it's HOT_UPDATED itself. Or have you found a smart way to\\n>> > figure that out?\\n>>\\n>> Hmm, sorry, I did think of that point and I thought I had added it to the doc.\\n>>\\n>> So, yes, I agree - re-locating the root is the biggest downside to\\n>> this idea. Perhaps Pavan has other thoughts?\\n>>\\n>> I think its doable, but it will be fiddly.\\n>\\n> I'm less afraid of the fiddlyness of finding the root tuple, than the\\n> cost. It's not cheap to walk through, potentially, all hot chains to\\n> find the root ctid.\\n>\\n> Have you considered what it'd take to allow index pointers to allow to\\n> point to \\\"intermediate\\\" root tuples? I.e. have some indexes point into\\n> the middle of an update-chain, whereas others still point to the\\n> beginning? There's certainly some complications involved with that, but\\n> it'd also have the advantage in reducing the amount of rechecking that\\n> needs to be done.\\n\\n\\\"Intermediate root tuples\\\" was my first attempt at this and it didn't\\nwork. I'll dig up the details, some problem in VACUUM, IIRC.\\n\\n-- \\nSimon Riggs 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, 4 Aug 2016 18:18:47 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 06:16:02PM +0100, Simon Riggs wrote:\\n> On 4 August 2016 at 18:05, Bruce Momjian <bruce@momjian.us> wrote:\\n> \\n> >> Approach 2 seems more reasonable and simple.\\n> >>\\n> >> There are only 2 bits for lp_flags and all combinations are already used. But\\n> >> for LP_REDIRECT root line pointer, we could use the lp_len field to store this\\n> >> special flag, which is not used for LP_REDIRECT line pointers. So we are able\\n> >> to mark the root line pointer.\\n> >\\n> > Uh, as I understand it, we only use LP_REDIRECT when we have _removed_\\n> > the tuple that the ctid was pointing to, but it seems you would need to\\n> > set HEAP_RECHECK_REQUIRED earlier than that.\\n> \\n> Hmm. Mostly there will be one, so this is just for the first update\\n> after any VACUUM.\\n> \\n> Adding a new linepointer just to hold this seems kludgy and could mean\\n> we run out of linepointers.\\n\\nAh, so in cases where there isn't an existing LP_REDIRECT for the chain,\\nyou create one and use the lp_len to identify it as a WARM chain? Hmm.\\n\\nYou can't update the indexes pointing to the existing ctid, so what you\\nwould really have to do is to write over the existing ctid with\\nLP_REDIRECT plus WARM marker, and move the old ctid to a new ctid slot?\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 4 Aug 2016 13:19:59 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 06:18:47PM +0100, Simon Riggs wrote:\\n> > Have you considered what it'd take to allow index pointers to allow to\\n> > point to \\\"intermediate\\\" root tuples? I.e. have some indexes point into\\n> > the middle of an update-chain, whereas others still point to the\\n> > beginning? There's certainly some complications involved with that, but\\n> > it'd also have the advantage in reducing the amount of rechecking that\\n> > needs to be done.\\n> \\n> \\\"Intermediate root tuples\\\" was my first attempt at this and it didn't\\n> work. I'll dig up the details, some problem in VACUUM, IIRC.\\n\\nI think the problem is that HOT chain pruning becomes almost impossible\\nexcept via VACUUM.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 4 Aug 2016 13:21:26 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On 2016-08-04 18:18:47 +0100, Simon Riggs wrote:\\n> On 4 August 2016 at 18:17, Andres Freund <andres@anarazel.de> wrote:\\n> > On 2016-08-04 18:11:17 +0100, Simon Riggs wrote:\\n> > I'm less afraid of the fiddlyness of finding the root tuple, than the\\n> > cost. It's not cheap to walk through, potentially, all hot chains to\\n> > find the root ctid.\\n> >\\n> > Have you considered what it'd take to allow index pointers to allow to\\n> > point to \\\"intermediate\\\" root tuples? I.e. have some indexes point into\\n> > the middle of an update-chain, whereas others still point to the\\n> > beginning? There's certainly some complications involved with that, but\\n> > it'd also have the advantage in reducing the amount of rechecking that\\n> > needs to be done.\\n> \\n> \\\"Intermediate root tuples\\\" was my first attempt at this and it didn't\\n> work. I'll dig up the details, some problem in VACUUM, IIRC.\\n\\nI think it's doable, but the question is how to do cleanup. It's kind of\\neasy to end up with a page full of line pointers which are all reachable\\nfrom indexes, but otherwise useless. But I'm not sure that's actually\\nthat inevitable:\\n\\na) Given that we fully scan indexes anyway, we could apply redirections\\n to the indexes themselves, during vacuum. Then redirections could be\\n removed afterwards.\\nb) Start fixing up indexes, by refinding entries in the index from the\\n heap tuple. That requires expressions to actually be immutable, but\\n personally I think it's stupid to cater for expressions that are\\n not. Then we can update indexes to point to the \\\"final tuple\\\" after\\n pruning. It'd also pave the way to avoid the full index scan at the\\n end of vacuum (in some cases).\\n\\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\": \"Thu, 4 Aug 2016 10:23:19 -0700\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 10:41 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n\\n> On 4 August 2016 at 17:31, Andres Freund <andres@anarazel.de> wrote:\\n> > Hi,\\n> >\\n> > On 2016-08-04 16:29:09 +0530, Pavan Deolasee wrote:\\n> >> Indexes whose values do not change do not require new index pointers.\\n> Only\\n> >> the index whose key is being changed will need a new index entry. The\\n> new\\n> >> index entry will be set to the CTID of the root line pointer.\\n> >\\n> > That seems to require tracing all hot-chains in a page, to actually\\n> > figure out what the root line pointer of a warm-updated HOT tuple is,\\n> > provided it's HOT_UPDATED itself. Or have you found a smart way to\\n> > figure that out?\\n>\\n> Hmm, sorry, I did think of that point and I thought I had added it to the\\n> doc.\\n>\\n> So, yes, I agree - re-locating the root is the biggest downside to\\n> this idea. Perhaps Pavan has other thoughts?\\n>\\n>\\nI clearly missed this problem, so what I say now is not fully thought\\nthrough. I see couple of options:\\n\\n1. Most often the tuple that's being updated will be fetched by recent\\nindex scan. So we can potentially cache last (few) mappings of CTID to\\ntheir root line pointers. May be we can store that in RelationData on a per\\nrelation basis.\\n2. I also think that most often the tuple that will be updated will have\\nits t_ctid pointing to itself. This sounds more invasive, but can we\\nsomehow utilise the t_ctid field to store the OffsetNumber of the root line\\npointer? The root line pointer only exists when the tuple under\\nconsideration has HEAP_ONLY_TUPLE flag set and we know for such tuples,\\nBlockNumber in t_ctid must be same as current block (unless HEAP_UPDATED is\\nalso set and the updating transaction eventually aborted).\\n\\nWe may have to fall back to a full page scan to find the root line pointer,\\nbut we can limit that for corner cases.\\n\\nThanks,\\nPavan\\n\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Thu, Aug 4, 2016 at 10:41 PM, Simon Riggs <simon@2ndquadrant.com> wrote:On 4 August 2016 at 17:31, Andres Freund <andres@anarazel.de> wrote:\\n> Hi,\\n>\\n> On 2016-08-04 16:29:09 +0530, Pavan Deolasee wrote:\\n>> Indexes whose values do not change do not require new index pointers. Only\\n>> the index whose key is being changed will need a new index entry. The new\\n>> index entry will be set to the CTID of the root line pointer.\\n>\\n> That seems to require tracing all hot-chains in a page, to actually\\n> figure out what the root line pointer of a warm-updated HOT tuple is,\\n> provided it's HOT_UPDATED itself. Or have you found a smart way to\\n> figure that out?\\n\\nHmm, sorry, I did think of that point and I thought I had added it to the doc.\\n\\nSo, yes, I agree - re-locating the root is the biggest downside to\\nthis idea. Perhaps Pavan has other thoughts?\\nI clearly missed this problem, so what I say now is not fully thought through. I see couple of options:1. Most often the tuple that's being updated will be fetched by recent index scan. So we can potentially cache last (few) mappings of CTID to their root line pointers. May be we can store that in RelationData on a per relation basis.2. I also think that most often the tuple that will be updated will have its t_ctid pointing to itself. This sounds more invasive, but can we somehow utilise the t_ctid field to store the OffsetNumber of the root line pointer? The root line pointer only exists when the tuple under consideration has HEAP_ONLY_TUPLE flag set and we know for such tuples, BlockNumber in t_ctid must be same as current block (unless HEAP_UPDATED is also set and the updating transaction eventually aborted).We may have to fall back to a full page scan to find the root line pointer, but we can limit that for corner cases.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Thu, 4 Aug 2016 22:58:33 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 10:49 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n\\n> On Thu, Aug 4, 2016 at 06:16:02PM +0100, Simon Riggs wrote:\\n> > On 4 August 2016 at 18:05, Bruce Momjian <bruce@momjian.us> wrote:\\n> >\\n> > >> Approach 2 seems more reasonable and simple.\\n> > >>\\n> > >> There are only 2 bits for lp_flags and all combinations are already\\n> used. But\\n> > >> for LP_REDIRECT root line pointer, we could use the lp_len field to\\n> store this\\n> > >> special flag, which is not used for LP_REDIRECT line pointers. So we\\n> are able\\n> > >> to mark the root line pointer.\\n> > >\\n> > > Uh, as I understand it, we only use LP_REDIRECT when we have _removed_\\n> > > the tuple that the ctid was pointing to, but it seems you would need to\\n> > > set HEAP_RECHECK_REQUIRED earlier than that.\\n> >\\n> > Hmm. Mostly there will be one, so this is just for the first update\\n> > after any VACUUM.\\n> >\\n> > Adding a new linepointer just to hold this seems kludgy and could mean\\n> > we run out of linepointers.\\n>\\n> Ah, so in cases where there isn't an existing LP_REDIRECT for the chain,\\n> you create one and use the lp_len to identify it as a WARM chain? Hmm.\\n>\\n>\\nIf the root tuple still exists, we store the WARM flag (or\\nHEAP_RECHECK_REQUIRED as used in the original post) in the tuple header\\nitself. When the root tuple becomes dead and HOT prune decides to replace\\nit with a LP_REDIRECT line pointer, the information is moved to lp_len\\n(which is currently set to 0 for LP_REDIRECT items). Does that answer your\\nquestion?\\n\\n\\n> You can't update the indexes pointing to the existing ctid, so what you\\n> would really have to do is to write over the existing ctid with\\n> LP_REDIRECT plus WARM marker, and move the old ctid to a new ctid slot?\\n>\\n>\\nNot really. I hope the above answers this, but please let me know if you\\nmean something else.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Thu, Aug 4, 2016 at 10:49 PM, Bruce Momjian <bruce@momjian.us> wrote:On Thu, Aug 4, 2016 at 06:16:02PM +0100, Simon Riggs wrote:\\n> On 4 August 2016 at 18:05, Bruce Momjian <bruce@momjian.us> wrote:\\n>\\n> >> Approach 2 seems more reasonable and simple.\\n> >>\\n> >> There are only 2 bits for lp_flags and all combinations are already used. But\\n> >> for LP_REDIRECT root line pointer, we could use the lp_len field to store this\\n> >> special flag, which is not used for LP_REDIRECT line pointers. So we are able\\n> >> to mark the root line pointer.\\n> >\\n> > Uh, as I understand it, we only use LP_REDIRECT when we have _removed_\\n> > the tuple that the ctid was pointing to, but it seems you would need to\\n> > set HEAP_RECHECK_REQUIRED earlier than that.\\n>\\n> Hmm. Mostly there will be one, so this is just for the first update\\n> after any VACUUM.\\n>\\n> Adding a new linepointer just to hold this seems kludgy and could mean\\n> we run out of linepointers.\\n\\nAh, so in cases where there isn't an existing LP_REDIRECT for the chain,\\nyou create one and use the lp_len to identify it as a WARM chain? Hmm.\\nIf the root tuple still exists, we store the WARM flag (or HEAP_RECHECK_REQUIRED as used in the original post) in the tuple header itself. When the root tuple becomes dead and HOT prune decides to replace it with a LP_REDIRECT line pointer, the information is moved to lp_len (which is currently set to 0 for LP_REDIRECT items). Does that answer your question? \\nYou can't update the indexes pointing to the existing ctid, so what you\\nwould really have to do is to write over the existing ctid with\\nLP_REDIRECT plus WARM marker, and move the old ctid to a new ctid slot?\\nNot really. I hope the above answers this, but please let me know if you mean something else. Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Thu, 4 Aug 2016 23:04:49 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 2:14 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> To fix this, what I was pondering, and I believe it would be viable,\\n> is to teach heap_hot_search_buffer about the WARM invariant. It will\\n> make correctness heavily depend on the invariant being true, which\\n> means either flagging item pointers as WARM chains, or requiring a\\n> reindex during upgrade to make sure all indexes verify the invariant -\\n> as old indices won't.\\n>\\n> When an item pointer is WARM (either implicit or explicit),\\n> heap_hot_search_buffer will only stop following the update chain if it\\n> reaches not the end of a HOT chain, but rather a key change. For this,\\n> it will need to recheck the key of all but the first TID in the chain,\\n> so singleton chains (ie: not-updated or frozen tuples) won't incurr\\n> this extra cost. When walking the chain, it will need to form an index\\n> tuple for both the old and new versions, and compare them, and follow\\n> the chain *only* if the keys are equal.\\n>\\n> As an optimization, if the tuple is marked HOT-updated, the key check\\n> may be skipped.\\n>\\n> Vacuum will need to be taught not to break the invariant, but I\\n> believe this is viable and efficient.\\n\\n\\nAnd I didn't mention the invariant.\\n\\nThe invariant would be that all WARM chains:\\n\\n * contain entire HOT chains (ie: no item pointers pointing to the\\nmiddle of a HOT chain)\\n * start at the item pointer, and end when the t_ctid of the heap\\ntuple either points to another page, or a tuple with a different index\\nkey\\n * there is exactly one WARM chain containing any heap tuple,\\nincluding the singleton chain represented by a tuple whose WARM chain\\ncontains only itself\\n\\nThis is maintained by:\\n\\n * No item pointer will be created for row versions whose immediately\\nprevious version is already on the index with the same key\\n\\nCleanup can only proceed by applying cleanup on HOT chains, by moving\\nthe head of a WARM chain forward, or by removing it entirely. It may\\nbe that VACUUM already works like that, but I'm unsure.\\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, 4 Aug 2016 14:35:32 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 11:04:49PM +0530, Pavan Deolasee wrote:\\n> If the root tuple still exists, we store the WARM flag (or\\n> HEAP_RECHECK_REQUIRED as used in the original post) in the tuple header itself.\\n> When the root tuple becomes dead and HOT prune decides to replace it with a\\n> LP_REDIRECT line pointer, the information is moved to lp_len (which is\\n> currently set to 0 for LP_REDIRECT items). Does that answer your question?\\n\\nAh, brilliant!\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 4 Aug 2016 13:49:43 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 01:05:53PM -0400, Bruce Momjian wrote:\\n> > Approach 2 seems more reasonable and simple.�\\n> > \\n> > There are only 2 bits for lp_flags and all combinations are already used. But\\n> > for LP_REDIRECT root line pointer, we could use the lp_len field to store this\\n> > special flag, which is not used for LP_REDIRECT line pointers. So we are able\\n> > to mark the root line pointer.\\n> \\n> Uh, as I understand it, we only use LP_REDIRECT when we have _removed_\\n> the tuple that the ctid was pointing to, but it seems you would need to\\n> set HEAP_RECHECK_REQUIRED earlier than that.\\n> \\n> Also, what is currently in the lp_len field for LP_REDIRECT? Zeros, or\\n> random data? I am asking for pg_upgrade purposes.\\n\\nIt seems LP_REDIRECT's lp_len is always zero: :-)\\n\\n\\t/*\\n\\t * ItemIdSetRedirect\\n\\t * Set the item identifier to be REDIRECT, with the specified link.\\n\\t * Beware of multiple evaluations of itemId!\\n\\t */\\n\\t#define ItemIdSetRedirect(itemId, link) \\\\\\n\\t( \\\\\\n\\t (itemId)->lp_flags = LP_REDIRECT, \\\\\\n\\t (itemId)->lp_off = (link), \\\\\\n\\t (itemId)->lp_len = 0 \\\\\\n\\t ^^^^^^^^^^\\n\\t)\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 4 Aug 2016 13:54:04 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 02:35:32PM -0300, Claudio Freire wrote:\\n> > Vacuum will need to be taught not to break the invariant, but I\\n> > believe this is viable and efficient.\\n> \\n> \\n> And I didn't mention the invariant.\\n> \\n> The invariant would be that all WARM chains:\\n> \\n> * contain entire HOT chains (ie: no item pointers pointing to the\\n> middle of a HOT chain)\\n\\nYou mean no _index_ item pointers, right?\\n\\n> * start at the item pointer, and end when the t_ctid of the heap\\n> tuple either points to another page, or a tuple with a different index\\n> key\\n\\nUh, there is only one visible tuple in a HOT chain, so I don't see the\\ndifferent index key as being a significant check. That is, I think we\\nshould check the visibility first, as we do now, and then, for the\\nonly-visible tuple, check the key. I don't see a value in (expensive)\\nchecking the key of an invisible tuple in hopes of stoping the HOT chain\\ntraversal.\\n\\nAlso, what happens when a tuple chain goes off-page, then returns to the\\noriginal page? That is a new HOT chain given our current code, but\\nwould the new tuple addition realize it needs to create a new index\\ntuple? The new tuple code needs to check the index's root HOT tid for a\\nnon-match.\\n\\n> This is maintained by:\\n> \\n> * No item pointer will be created for row versions whose immediately\\n> previous version is already on the index with the same key\\n\\nYou really only have the ctid HOT head stored in the index, not the\\nimmediate ctid.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 4 Aug 2016 14:07:46 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 3:07 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n> On Thu, Aug 4, 2016 at 02:35:32PM -0300, Claudio Freire wrote:\\n>> > Vacuum will need to be taught not to break the invariant, but I\\n>> > believe this is viable and efficient.\\n>>\\n>>\\n>> And I didn't mention the invariant.\\n>>\\n>> The invariant would be that all WARM chains:\\n>>\\n>> * contain entire HOT chains (ie: no item pointers pointing to the\\n>> middle of a HOT chain)\\n>\\n> You mean no _index_ item pointers, right?\\n\\nYes\\n\\n>> * start at the item pointer, and end when the t_ctid of the heap\\n>> tuple either points to another page, or a tuple with a different index\\n>> key\\n>\\n> Uh, there is only one visible tuple in a HOT chain, so I don't see the\\n> different index key as being a significant check.\\n\\nFor a HOT chain, sure. That's why I mentioned it as an optimization.\\n\\nBut t_ctid, I checked, unless I read the code wrong, is set for\\nnon-HOT updates too.\\n\\nSo following t_ctid regardless of the HOT-update flags should yield\\nupdate chains that can walk several buffers, and that's in fact the\\nmechanism I'm proposing, only just stop following the chain when it\\njumps buffers.\\n\\n> That is, I think we\\n> should check the visibility first, as we do now, and then, for the\\n> only-visible tuple, check the key.\\n\\nNo, because, as I explained in the example, doing that will result in\\nduplicates being returned.\\n\\nThe whole update chain can span multiple WARM chains, and each WARM\\nchain can span multiple HOT chains.\\n\\nConsider, assuming there's an index on id and another on val:\\n\\nINSERT INTO TABLE t (id,val,dat) VALUES (32,'a','blabla');\\nUPDATE t SET dat='blabla2' where id = 32;\\nUPDATE t SET dat='blabla3', id=33 where id = 32;\\nUPDATE t SET val='b' where id = 33;\\nUPDATE t SET dat='blabla4' where id = 33;\\nUPDATE t SET val='a' where id = 33;\\n\\nThis produces a case similar to the one I described. Assuming all\\nupdates happen on the same page, the first will be HOT, so no key\\ncheck is needed. The second cannot be HOT, because it updates the id.\\nBut it can be WARM, if it's done on the same page, so it can avoid\\nupdating the index on val. The third will need a new index item\\npointer, because it has a new key. The t_ctid chain will walk all the\\nversions of the row, but the one with 'blabla2' will not have the\\nHOT-updated bit set. So regular HOT chain walking will stop there, I\\npropose to not stop there, so the index on val can follow the chain\\ninto blabla3 as if it were a HOT update. Correctness is achieved only\\nif there is no index item pointer on that index pointing to that index\\nversion, and since there is no efficient way of checking, the\\ninvariants I propose aim to guarantee it so it can be assumed. Since\\nWARM updates don't create new index item pointers, what needs to be\\nchecked is whether updating from version 2 to version 3 would be a\\nWARM update on this index or not, and that equals to checking the\\nindex keys for equality.\\n\\n> I don't see a value in (expensive)\\n> checking the key of an invisible tuple in hopes of stoping the HOT chain\\n> traversal.\\n\\nNot HOT chain, the point is to guarantee correctness by properly\\nidentifying the end of the WARM (not HOT) chain, which is left\\nimplicit.\\n\\n> Also, what happens when a tuple chain goes off-page, then returns to the\\n> original page?\\n\\nThe WARM chain ends on the page hop, and when it returns it's a new\\nWARM chain. So traversal would not follow t_ctid pointers that hop\\npages, which makes it efficient, and also guarantees correctness\\n(since if the is a page hop, we know the index will contain an item\\npointer to the version in that other page, so we'll visit it when we\\nget there).\\n\\n> That is a new HOT chain given our current code, but\\n> would the new tuple addition realize it needs to create a new index\\n> tuple? The new tuple code needs to check the index's root HOT tid for a\\n> non-match.\\n\\nI'm not proposing to change how HOT works, but adding another very\\nsimilar mechanism on top of it called WARM.\\n\\nSo HOT will keep working like that, HOT pruning will happen as usual,\\nbut we'll have the concept (immaterialized in the physical\\nrepresentation of the data, just implicit) of WARM chains. WARM chains\\nwould span one or several HOT chains, so they're \\\"bigger\\\".\\n\\n>> This is maintained by:\\n>>\\n>> * No item pointer will be created for row versions whose immediately\\n>> previous version is already on the index with the same key\\n>\\n> You really only have the ctid HOT head stored in the index, not the\\n> immediate ctid.\\n\\nI know. I just mentioned it just in case there was a transient time\\nduring cleanup when it isn't true, but thinking it a little bit more,\\nif it weren't, HOT would also cause duplicates during index scans, so\\nit's probably not the case (or protected with a lock).\\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, 4 Aug 2016 15:23:10 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 3:23 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> That is a new HOT chain given our current code, but\\n>> would the new tuple addition realize it needs to create a new index\\n>> tuple? The new tuple code needs to check the index's root HOT tid for a\\n>> non-match.\\n>\\n> I'm not proposing to change how HOT works, but adding another very\\n> similar mechanism on top of it called WARM.\\n>\\n> So HOT will keep working like that, HOT pruning will happen as usual,\\n> but we'll have the concept (immaterialized in the physical\\n> representation of the data, just implicit) of WARM chains. WARM chains\\n> would span one or several HOT chains, so they're \\\"bigger\\\".\\n\\n\\nAnswering your question, there's no need to find the root page on index updates.\\n\\nWhen creating the new tuple in nodeModifyTable.c, the code currently\\nskips updating indexes if it's using HOT.\\n\\nWe would add a check for WARM too. It will use WARM for index X iff both:\\n\\n * ItemPointerGetBlockNumber(oldtuplectid) ==\\nItemPointerGetBlockNumber(newtuplectid)\\n * satisfies HOT for only this index X\\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, 4 Aug 2016 15:33:16 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 03:23:10PM -0300, Claudio Freire wrote:\\n> INSERT INTO TABLE t (id,val,dat) VALUES (32,'a','blabla');\\n> UPDATE t SET dat='blabla2' where id = 32;\\n> UPDATE t SET dat='blabla3', id=33 where id = 32;\\n> UPDATE t SET val='b' where id = 33;\\n> UPDATE t SET dat='blabla4' where id = 33;\\n> UPDATE t SET val='a' where id = 33;\\n> \\n> This produces a case similar to the one I described. Assuming all\\n> updates happen on the same page, the first will be HOT, so no key\\n> check is needed. The second cannot be HOT, because it updates the id.\\n> But it can be WARM, if it's done on the same page, so it can avoid\\n> updating the index on val. The third will need a new index item\\n> pointer, because it has a new key. The t_ctid chain will walk all the\\n> versions of the row, but the one with 'blabla2' will not have the\\n> HOT-updated bit set. So regular HOT chain walking will stop there, I\\n> propose to not stop there, so the index on val can follow the chain\\n> into blabla3 as if it were a HOT update. Correctness is achieved only\\n> if there is no index item pointer on that index pointing to that index\\n> version, and since there is no efficient way of checking, the\\n> invariants I propose aim to guarantee it so it can be assumed. Since\\n> WARM updates don't create new index item pointers, what needs to be\\n> checked is whether updating from version 2 to version 3 would be a\\n> WARM update on this index or not, and that equals to checking the\\n> index keys for equality.\\n\\nOK, it took me a while to understand this, so let me see if I can\\nrestate it. You have an update chain in a single page which is made up\\nof one ore more HOT chains, some of which might be WARM. A flag\\nindicates a WARM chain (see below). A WARM chain cannot go outside of a\\nHOT chain.\\n\\nThe HOT chains have identical keys for all indexes, and the WARM chains\\nhave identical keys for some indexes. If an update chain is all on the\\nsame page, it can have multiple HOT chains. I think this is possible if\\nan update changes _all_ indexed columns in the middle of an update\\nchain, turning off HOT and WARM.\\n\\nI think we agreed that WARM index tuples will point to the head of the\\nHOT update chain on the same page. We will store the\\nHEAP_RECHECK_REQUIRED flag on the update chain head tuple, or on the\\nLP_REDIRECT ctid if we removed the tuple during HOT cleanup.\\n\\nSo, I think the case you are discussing is walking WARM beyond the end\\nof the HOT chain so you don't have to create a second index entry for\\nthe second HOT chain in the same update chain for matching values. \\n\\nFor example, you have a HOT chain, and you set the indexed col1=2, then\\nlater, in the same HOT chain, change it to col1=4, then later, in the\\nsame HOT chain, back to col1=2. I assume the last update would see\\nthere was already an index entry pointing to the head of the same HOT\\nchain, and would skip adding to the index.\\n\\nHowever, you might be saying that the last update of col1=2 makes a\\nnon-HOT entry in the update chain, and you want to find that without\\nadding an index entry.\\n\\nThat seems overly complex and not worth it.\\n\\nAnother approach would be to keep updates on the same page in a single\\nWARM chain, even if all indexes have changed columns. We will already\\nhave code to walk the HOT chain looking for matches, and at most one\\ntuple in the update chain is visible. The downside of this is\\nunnecessary checking if the tuple matches the index.\\n\\n> > I don't see a value in (expensive)\\n> > checking the key of an invisible tuple in hopes of stoping the HOT chain\\n> > traversal.\\n> \\n> Not HOT chain, the point is to guarantee correctness by properly\\n> identifying the end of the WARM (not HOT) chain, which is left\\n> implicit.\\n\\nWhy should WARM chains span beyond HOT chains?\\n\\n> > Also, what happens when a tuple chain goes off-page, then returns to the\\n> > original page?\\n> \\n> The WARM chain ends on the page hop, and when it returns it's a new\\n> WARM chain. So traversal would not follow t_ctid pointers that hop\\n> pages, which makes it efficient, and also guarantees correctness\\n> (since if the is a page hop, we know the index will contain an item\\n> pointer to the version in that other page, so we'll visit it when we\\n> get there).\\n> \\n> > That is a new HOT chain given our current code, but\\n> > would the new tuple addition realize it needs to create a new index\\n> > tuple? The new tuple code needs to check the index's root HOT tid for a\\n> > non-match.\\n> \\n> I'm not proposing to change how HOT works, but adding another very\\n> similar mechanism on top of it called WARM.\\n> \\n> So HOT will keep working like that, HOT pruning will happen as usual,\\n> but we'll have the concept (immaterialized in the physical\\n> representation of the data, just implicit) of WARM chains. WARM chains\\n> would span one or several HOT chains, so they're \\\"bigger\\\".\\n\\nYes, I think I got it, but what is the benefit? Fewer index entries?\\n\\nAs I see it, the only way with WARM you could have an update chain on\\nthe same page that has multiple HOT chains is if you changed all the\\nindexed columns. The complexity and rechecking of handling that doesn't\\nseem worth trying to avoid index entries for the second HOT chain.\\n\\n> >> This is maintained by:\\n> >>\\n> >> * No item pointer will be created for row versions whose immediately\\n> >> previous version is already on the index with the same key\\n> >\\n> > You really only have the ctid HOT head stored in the index, not the\\n> > immediate ctid.\\n> \\n> I know. I just mentioned it just in case there was a transient time\\n> during cleanup when it isn't true, but thinking it a little bit more,\\n> if it weren't, HOT would also cause duplicates during index scans, so\\n> it's probably not the case (or protected with a lock).\\n\\nI am looking for clarification on this posting.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 4 Aug 2016 18:21:48 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 03:33:16PM -0300, Claudio Freire wrote:\\n> On Thu, Aug 4, 2016 at 3:23 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> >> That is a new HOT chain given our current code, but\\n> >> would the new tuple addition realize it needs to create a new index\\n> >> tuple? The new tuple code needs to check the index's root HOT tid for a\\n> >> non-match.\\n> >\\n> > I'm not proposing to change how HOT works, but adding another very\\n> > similar mechanism on top of it called WARM.\\n> >\\n> > So HOT will keep working like that, HOT pruning will happen as usual,\\n> > but we'll have the concept (immaterialized in the physical\\n> > representation of the data, just implicit) of WARM chains. WARM chains\\n> > would span one or several HOT chains, so they're \\\"bigger\\\".\\n> \\n> \\n> Answering your question, there's no need to find the root page on index updates.\\n> \\n> When creating the new tuple in nodeModifyTable.c, the code currently\\n> skips updating indexes if it's using HOT.\\n> \\n> We would add a check for WARM too. It will use WARM for index X iff both:\\n> \\n> * ItemPointerGetBlockNumber(oldtuplectid) ==\\n> ItemPointerGetBlockNumber(newtuplectid)\\n> * satisfies HOT for only this index X\\n\\nOK, I see why you like walking the entire update chain instead of just\\nwalking the HOT chain --- you think it avoids us having to find the HOT\\nchain root. However, how do you check the index to find out of the\\nupdate chain root is already in the index? I don't think you can just\\nlook at the current tuple to know that since a previous tuple in the\\nupdate chain might have put it there even if the current old tuple\\nwouldn't have.\\n\\nMy point is there can be multiple update chains on the same page for\\ndifferent rows with identical indexed values, so I don't see how\\nchecking just for the page number helps here. Are we going to check the\\nentire page?\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 4 Aug 2016 18:41:23 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 10:58:33PM +0530, Pavan Deolasee wrote:\\n> 2. I also think that most often the tuple that will be updated will have its\\n> t_ctid pointing to itself. This sounds more invasive, but can we somehow\\n\\nAgreed! I think it has to. Great idea.\\n\\n> utilise the t_ctid field to store the OffsetNumber of the root line pointer?\\n> The root line pointer only exists when the tuple under consideration has\\n> HEAP_ONLY_TUPLE flag set and we know for such tuples, BlockNumber in t_ctid\\n> must be same as current block (unless HEAP_UPDATED is also set and the updating\\n> transaction eventually aborted).\\n\\nOh, aborts, so the tuple we are looking at is the head of the chain and\\npoints to a tuple that was aborted. So we would still need a page-scan\\nto handle cases where the t_ctid was over-written by an aborted tuple,\\nbut as you said it would be rare.\\n\\nSo, if the tuple has HEAP_ONLY_TUPLE set, we know the block number\\nip_blkid equals our block number, so any ip_blkid value that doesn't\\nequal our block number is a special flag that indicates that ip_posid\\npoints to the head of our HOT chain. I guess we could just set it to\\n(our block number + 1), with rollover possible and desired.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 4 Aug 2016 19:31:28 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 7:21 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n> On Thu, Aug 4, 2016 at 03:23:10PM -0300, Claudio Freire wrote:\\n>> INSERT INTO TABLE t (id,val,dat) VALUES (32,'a','blabla');\\n>> UPDATE t SET dat='blabla2' where id = 32;\\n>> UPDATE t SET dat='blabla3', id=33 where id = 32;\\n>> UPDATE t SET val='b' where id = 33;\\n>> UPDATE t SET dat='blabla4' where id = 33;\\n>> UPDATE t SET val='a' where id = 33;\\n>>\\n>> This produces a case similar to the one I described. Assuming all\\n>> updates happen on the same page, the first will be HOT, so no key\\n>> check is needed. The second cannot be HOT, because it updates the id.\\n>> But it can be WARM, if it's done on the same page, so it can avoid\\n>> updating the index on val. The third will need a new index item\\n>> pointer, because it has a new key. The t_ctid chain will walk all the\\n>> versions of the row, but the one with 'blabla2' will not have the\\n>> HOT-updated bit set. So regular HOT chain walking will stop there, I\\n>> propose to not stop there, so the index on val can follow the chain\\n>> into blabla3 as if it were a HOT update. Correctness is achieved only\\n>> if there is no index item pointer on that index pointing to that index\\n>> version, and since there is no efficient way of checking, the\\n>> invariants I propose aim to guarantee it so it can be assumed. Since\\n>> WARM updates don't create new index item pointers, what needs to be\\n>> checked is whether updating from version 2 to version 3 would be a\\n>> WARM update on this index or not, and that equals to checking the\\n>> index keys for equality.\\n>\\n> OK, it took me a while to understand this, so let me see if I can\\n> restate it. You have an update chain in a single page which is made up\\n> of one ore more HOT chains, some of which might be WARM. A flag\\n> indicates a WARM chain (see below). A WARM chain cannot go outside of a\\n> HOT chain.\\n\\nIt's the other way around. A WARM chain has to span whole HOT chains.\\nThe WARM chain always begins in the head of a HOT chain (or non-HOT\\ntuple of course), and cannot end before the HOT chain ends.\\n\\nThat is, all within a single page:\\n\\n [ v1 .. v2 .. v3 .. v4 .. v5 .. v6 v7 ]\\n [ hot chain 1 ][ hot chain 2 ] [NH]\\n [ WARM CHAIN ] [NW]\\n\\n(NH = non-HOT)\\n(NW = non-WARM)\\n\\nThe flag could be useful for the upgrade path, but if you ignore\\nhaving to live with old-format indexes, it's not necessary.\\n\\nA WARM chain starts at any index item pointer. It ends when there's a\\nkey change or a page change (ie: the WARM chain cannot span multiple\\npages). That cannot happen within a HOT chain, so that point will also\\nbe the end of a HOT chain.\\n\\nYou can think of a WARM chain as a chain of HOT chains.\\n\\n> The HOT chains have identical keys for all indexes, and the WARM chains\\n> have identical keys for some indexes.\\n\\nLets highlight that a WARM chain concept only exists in the context of\\na specific index. WARM chains (the way I describe them) apply to only\\none index at a time.\\n\\nSo, different indexes will have different chaining of HOT chains into\\nWARM chains. While index A may chain HOT chain 1 and HOT chain 2\\ntogether, index B may not. In fact, the way WARM works garantees that\\nat least one index won't chain them.\\n\\nSo WARM chains have identical keys for a specific index. Different\\nindexes have different WARM chains.\\n\\n> If an update chain is all on the\\n> same page, it can have multiple HOT chains. I think this is possible if\\n> an update changes _all_ indexed columns in the middle of an update\\n> chain, turning off HOT and WARM.\\n\\nYes\\n\\n> I think we agreed that WARM index tuples will point to the head of the\\n> HOT update chain on the same page.\\n\\nThe head of the WARM chain, which may not be the HOT update chain.\\n\\nIn the above example, the WARM index tuple would point to the head of\\nthe hot chain 1, not hot chain 2.\\n\\n> We will store the\\n> HEAP_RECHECK_REQUIRED flag on the update chain head tuple, or on the\\n> LP_REDIRECT ctid if we removed the tuple during HOT cleanup.\\n\\nI wouldn't put it on the update chain head, I'd put it on the\\njust-inserted heap tuple, and I'd call it HEAP_WARM_TUPLE. I wouldn't\\nuse a corresponding HEAP_WARM_UPDATED, there's no need to update the\\nold tuple's flags.\\n\\nThe purpose of the flag is to be able to discern new-style index\\npointers from old-style ones, since they require different ways of\\nfollowing the update chain.\\n\\nIn the example above, old indexes will have item pointers to the head\\nof hot chain 1 and 2. A scan that finds the item pointer for hot chain\\n1 has to scan the HOT chain only, and not step into hot chain 2,\\nbecause there's an item pointer for hot chain 2 already. New indexes\\nneed to follow through the end of HOT chain 1 into HOT chain 2,\\nbecause there won't be an item pointer pointing to the head of HOT\\nchain 2. The flag being set in the tuple would signal that this is a\\nnew-style update, so it needs to follow the WARM chain, whereas if the\\nflag is 0, it needs not. It allows for a painless upgrade, but that's\\nit.\\n\\nThe flag alone doesn't remove the need to perform the key check.\\nBecause what's a WARM update for one index may be a regular update for\\nanother, and you can't store that level of detail on heap tuple flags.\\n\\nHOT cleanup, I believe, needs to move the HEAP_WARM_TUPLE flag as it\\nmoves the head. Or HOT updates could copy the flag across all HOT\\ntuples. The last way would mean HOT cleanup needs no modifications.\\n\\n\\n> So, I think the case you are discussing is walking WARM beyond the end\\n> of the HOT chain so you don't have to create a second index entry for\\n> the second HOT chain in the same update chain for matching values.\\n\\nExactly.\\n\\n> For example, you have a HOT chain, and you set the indexed col1=2, then\\n> later, in the same HOT chain, change it to col1=4, then later, in the\\n> same HOT chain, back to col1=2. I assume the last update would see\\n> there was already an index entry pointing to the head of the same HOT\\n> chain, and would skip adding to the index.\\n\\nIf an indexed col1 is updated, the update isn't HOT. May be WARM, but not HOT.\\n\\nAssume WARM, that is, there is an index on col1 but it's not the index\\nwe're updating. How would you do that efficiently?\\n\\nFor unique indexes maybe, but for non-unique, a key could match an\\nunbounded number of rows, and scanning all item tuples to find the\\nright one would be extremely expensive.\\n\\nThe mechanism for deciding not to add an index entry, then, is key\\nchanges. As in the case of HOT, if no indexed (for this index) columns\\nchange, there's no need to add an index entry. So only the initial\\ninsert will create an index entry, and then WARM will know to follow\\nthe update chain even if it crosses HOT chain boundaries, **because\\nthe keys don't change**.\\n\\n> However, you might be saying that the last update of col1=2 makes a\\n> non-HOT entry in the update chain, and you want to find that without\\n> adding an index entry.\\n\\nYes.\\n\\nThe way I understood the initial proposal (similarly mine) is that\\nWARM would avoid adding index entries for some non-HOT updates in some\\nindexes.\\n\\nSo, suppose you have a row, and update it always in non-HOT (to\\nsimplify things) but WARM ways (including an indexed column, just not\\nthe index in question).\\n\\nThere are no HOT chains, only an update chain. You can have only a\\nsingle index entry like this, and it works:\\n\\nix1>(a, 1) -> (a, 2) -> (a, 3) -> (a, 4)\\n\\nThen you update the first column which is the index key. The index\\nwill need a new index entry or lookups may fail:\\n\\nix1>(a, 1) -> (a, 2) -> (a, 3) -> (a, 4) -> ix2>(b, 5)\\n\\nAnd you go back to the old value. You get:\\n\\nix1>(a, 1) -> (a, 2) -> (a, 3) -> (a, 4) -> ix2>(b, 5) -> ?>(a, 6)\\n\\nNow here you do have a choice, new index entry or not. In order to\\ndecide that, however, you have to find ix1. But ix1 could be anywhere\\non the tid list for key 'a', and in some cases that key could match\\nmillions (or more) tids. So I don't believe finding it through the\\nindex would be efficient. The only item you do know exists is ix2.\\nMaybe you could backtrack the update chain to find the root, but that\\nwould be expensive. How expensive? How does it compare to the options?\\nLets see\\n\\nSo, if you *don't* create an index entry there, you need to find the\\nroot ix1. That's doable with some CPU cost and no I/O (just\\nbacktracking index pointers). That would slow down inserts, I'm not\\nsure how much relative to other options.\\nAnd when you do find it, you need to compare the keys, ix1 could have\\npointed to (c, 1) and then an index entry is absolutely necessary. You\\nalso have to compare all the keys for the whole chain, there could be\\nkeys in the middle with index entries, and any one of those could be\\n'a', so you need to walk the chain from ix1 onward comparing keys as\\nyou see them. If the update chain is long, this would be rather\\nexpensive. Sure, no need to compare keys within a HOT chain, but here\\nthere's no HOT chain, they're all non-HOT updates.\\n\\nSo, what I was proposing is to always add an index entry when there's\\na key change:\\n\\nix1>(a, 1) -> (a, 2) -> (a, 3) -> (a, 4) -> ix2>(b, 5) -> ix3>(a, 6)\\n\\nThat's simpler to decide at insert time, just one key comparison (that\\nwas already done to decide HOT, mind you).\\n\\nBut at scan time, we'll find two index entries for key a: ix1 and ix3,\\n**both of which can reach a visible tuple** (only not consecutively,\\nso there's no way to know when you find ix1 that you will find ix3).\\n\\nSo the scan code needs a way to decide to stop scanning the update\\nchain when it reaches ix3, without actually seeing ix3 (it may be\\nanywhere else on the index). The way I came up with, is to check index\\nkeys between HOT chains. Since we always add an index entry when keys\\nchange, if keys change, we stop scanning becuase we *will* find\\nanother index entry that will point to that place and continue the\\nscan. If we kept scanning, we would scan the remainder of the chain\\nmultiple times.\\n\\nYes, it's expensive, but you pay a smaller price, relatively the size\\nof a recheck node: only one key recheck when going from one HOT chain\\nto another (vs analyzing a whole page of them during inserts).\\n\\nI prefer that tradeoff, but I guess some people might prefer the\\nother, depending on access patterns.\\n\\n\\n> That seems overly complex and not worth it.\\n>\\n> Another approach would be to keep updates on the same page in a single\\n> WARM chain, even if all indexes have changed columns. We will already\\n> have code to walk the HOT chain looking for matches, and at most one\\n> tuple in the update chain is visible. The downside of this is\\n> unnecessary checking if the tuple matches the index.\\n\\nThe problem with that is, how to avoid visiting the same version twice\\nwhen visiting more than one index entry that points to the same chain?\\n\\nThat's unavoidable when indexed keys do change mid-way. You can't add\\na flag for that anywhere on the heap, since the value depends on the\\npoint of view (from the index being used).\\n\\n>> >> This is maintained by:\\n>> >>\\n>> >> * No item pointer will be created for row versions whose immediately\\n>> >> previous version is already on the index with the same key\\n>> >\\n>> > You really only have the ctid HOT head stored in the index, not the\\n>> > immediate ctid.\\n>>\\n>> I know. I just mentioned it just in case there was a transient time\\n>> during cleanup when it isn't true, but thinking it a little bit more,\\n>> if it weren't, HOT would also cause duplicates during index scans, so\\n>> it's probably not the case (or protected with a lock).\\n>\\n> I am looking for clarification on this posting.\\n\\nJust ignore it. I thought it might be a source of trouble but that's\\nnot the case.\\n\\n\\nSo, summarizing:\\n\\nDuring update:\\n\\n * If the tuple satisfies HOT for at least one index, HEAP_WARM_TUPLE\\nis set on the new, perhaps HEAP_WARM_UPDATED on the old\\n * If the tuple satisfies HOT for all indexes, HEAP_ONLY_TUPLE is set,\\nHEAP_HOT_UPDATED on the old\\n * For each index that didn't satisfy HOT (that is, had key changes):\\n - insert new index entry\\n\\nDuring scan:\\n\\n * Set needs_recheck to false\\n * Follow redirects and update chains as usual\\n * When a tuple doesn't have either HEAP_HOT_UPDATED or\\nHEAP_WARM_UPDATED, stop following the chain\\n * If a tuple only has HEAP_WARM_UPDATED and not HEAP_HOT_UPDATED:\\n - Find the next tuple, compare keys\\n - Stop if keys differ\\n - Otherwise, set needs_recheck to true and follow the chain\\n\\nHOT cleanup works as usual\\n\\nVacuum I haven't researched yet, it's possible that it will need\\nchanges to not break WARM chains, since dead index pointers could\\nstill be necessary to reach live tuples.\\n\\n\\nAlternatively, without rechecks on non-visible keys:\\n\\nDuring update:\\n\\n * If the tuple satisfies HOT for at least one index, HEAP_WARM_TUPLE\\nis set on the new, perhaps HEAP_WARM_UPDATED on the old\\n * If the tuple satisfies HOT for all indexes, HEAP_ONLY_TUPLE is set,\\nHEAP_HOT_UPDATED on the old\\n * If HEAP_ONLY_TUPLE is not set, for all indexes:\\n - invoke index_insert:\\n - Map update chains of the whole heap page, find root entry for\\nthe new tuple (checking HEAP_WARM_UPDATED flags)\\n - Walk forward from the root, following t_ctid, comparing keys\\nagainst the new key\\n - Insert new entry iff there was no matching key\\n\\nDuring scan:\\n\\n * Set needs_recheck to false\\n * Follow redirects and update chains as usual\\n * When a tuple doesn't have either HEAP_HOT_UPDATED or\\nHEAP_WARM_UPDATED, stop following the chain\\n * If a tuple only has HEAP_WARM_UPDATED and not HEAP_HOT_UPDATED:\\n - set needs_recheck to true and follow the chain\\n\\nHOT cleanup works as usual\\n\\nThe alternatives differ only on the performance tradeoffs, they both\\navoid updating indexes unnecessarily. The second one may avoid more\\nupdates than the first and provide faster scans, but slower updates.\\n\\nTough choice.\\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, 4 Aug 2016 21:53:31 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \">On Thu, Aug 4, 2016 at 06:21:48PM -0400, Bruce Momjian wrote:\\n> Another approach would be to keep updates on the same page in a single\\n> WARM chain, even if all indexes have changed columns. We will already\\n> have code to walk the HOT chain looking for matches, and at most one\\n> tuple in the update chain is visible. The downside of this is\\n> unnecessary checking if the tuple matches the index.\\n\\nForget this idea I had. If all the indexed keys change, we don't save\\nanything in fewer index tuples, and we extend the length of the HOT\\nchain because we always have to point to the root of the HOT chain in\\nthe index.\\n\\nThe only advantage would be allowing reuse of the old index tuple if the\\nindexed value changes back to and old indexed value in the same chain,\\nwhich seems rare.\\n\\nLet me say I am excited at the progress that has been made on this item\\nin the past 36 hours and I think we are triangulating on a solution.\\n\\nI know we are restricted by the existing page format and pg_upgrade in\\nadding this features, but frankly that limitation seems minor --- even\\nif designing a new storage system, figuring out how to do WARM chains\\nefficiently would be hard.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 4 Aug 2016 21:00:48 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 7:59 AM, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:\\n> So marking the index would require us to mark both old and new index tuples\\n> as requiring re-check. That requires an additional index scan to locate the\\n> old row and then an additional write to force it to re-check, which is\\n> algorithmically O(NlogN) on table size.\\n\\n\\nSo, basically, I'm saying this isn't really O(NlogN), it's O(N),\\nmanifested in low-cardinality indexes.\\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, 4 Aug 2016 22:18:25 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 09:53:31PM -0300, Claudio Freire wrote:\\n> It's the other way around. A WARM chain has to span whole HOT chains.\\n> The WARM chain always begins in the head of a HOT chain (or non-HOT\\n> tuple of course), and cannot end before the HOT chain ends.\\n> \\n> That is, all within a single page:\\n> \\n> [ v1 .. v2 .. v3 .. v4 .. v5 .. v6 v7 ]\\n> [ hot chain 1 ][ hot chain 2 ] [NH]\\n> [ WARM CHAIN ] [NW]\\n> \\n> (NH = non-HOT)\\n> (NW = non-WARM)\\n> \\n> The flag could be useful for the upgrade path, but if you ignore\\n> having to live with old-format indexes, it's not necessary.\\n> \\n> A WARM chain starts at any index item pointer. It ends when there's a\\n> key change or a page change (ie: the WARM chain cannot span multiple\\n> pages). That cannot happen within a HOT chain, so that point will also\\n> be the end of a HOT chain.\\n> \\n> You can think of a WARM chain as a chain of HOT chains.\\n\\nOK, that's a lot of text, and I am confused. Please tell me the\\nadvantage of having an index point to a string of HOT chains, rather\\nthan a single one? Is the advantage that the index points into the\\nmiddle of the HOT chain rather than at the beginning? I can see some\\nvalue to that, but having more ctid HOT headers that can't be removed\\nexcept by VACUUM seems bad, plus the need for index rechecks as you\\ncross to the next HOT chain seems bad.\\n\\nThe value of WARM is to avoid index bloat --- right now we traverse the\\nHOT chain on a single page just fine with no complaints about speed so I\\ndon't see a value to optimizing that traversal, and I think the key\\nrechecks and ctid bloat will make it all much slower.\\n\\nIt also seems much more complicated.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 4 Aug 2016 22:15:22 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 11:15 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n> On Thu, Aug 4, 2016 at 09:53:31PM -0300, Claudio Freire wrote:\\n>> It's the other way around. A WARM chain has to span whole HOT chains.\\n>> The WARM chain always begins in the head of a HOT chain (or non-HOT\\n>> tuple of course), and cannot end before the HOT chain ends.\\n>>\\n>> That is, all within a single page:\\n>>\\n>> [ v1 .. v2 .. v3 .. v4 .. v5 .. v6 v7 ]\\n>> [ hot chain 1 ][ hot chain 2 ] [NH]\\n>> [ WARM CHAIN ] [NW]\\n>>\\n>> (NH = non-HOT)\\n>> (NW = non-WARM)\\n>>\\n>> The flag could be useful for the upgrade path, but if you ignore\\n>> having to live with old-format indexes, it's not necessary.\\n>>\\n>> A WARM chain starts at any index item pointer. It ends when there's a\\n>> key change or a page change (ie: the WARM chain cannot span multiple\\n>> pages). That cannot happen within a HOT chain, so that point will also\\n>> be the end of a HOT chain.\\n>>\\n>> You can think of a WARM chain as a chain of HOT chains.\\n>\\n> OK, that's a lot of text, and I am confused. Please tell me the\\n> advantage of having an index point to a string of HOT chains, rather\\n> than a single one? Is the advantage that the index points into the\\n> middle of the HOT chain rather than at the beginning? I can see some\\n> value to that, but having more ctid HOT headers that can't be removed\\n> except by VACUUM seems bad, plus the need for index rechecks as you\\n> cross to the next HOT chain seems bad.\\n>\\n> The value of WARM is to avoid index bloat --- right now we traverse the\\n> HOT chain on a single page just fine with no complaints about speed so I\\n> don't see a value to optimizing that traversal, and I think the key\\n> rechecks and ctid bloat will make it all much slower.\\n>\\n> It also seems much more complicated.\\n\\nThe point is avoiding duplicate rows in the output of index scans.\\n\\nI don't think you can avoid it simply by applying index condition\\nrechecks as the original proposal implies, in this case:\\n\\nCREATE TABLE t (id integer not null primary key, someid integer, dat integer);\\nCREATE INDEX i1 ON t (someid);\\n\\nINSERT INTO t (id, someid, dat) VALUES (1, 2, 100);\\nUPDATE t SET dat = dat + 1 where id = 1;\\nUPDATE t SET dat = dat + 1, id = 2 where id = 1;\\nUPDATE t SET dat = dat + 1, id = 3, someid = 3 where id = 2;\\nUPDATE t SET dat = dat + 1, id = 1, someid = 2 where id = 3;\\nSELECT * FROM t WHERE someid = 2;\\n\\nThat, I believe, will cause the problematic chains where the condition\\nrecheck passes both times the last visible tuple is visited during the\\nscan. It will return more than one tuple when in reality there is only\\none.\\n\\nNot to mention the cost of scanning the chain of N tuples N times,\\nmaking it quadratic - bound by the number of tuples that can fit a\\npage, but still high.\\n\\nSolving that, I believe, will remove all the simplicity of pointing to\\nroot tuples.\\n\\nThis is done in my proposals by adding boundaries to WARM chains such\\nthat potential matches are visited only once (first variant) or\\nguaranteeing that visible tuples with a particular key will be\\nreachable from only one index entry (second variant). Pointing to the\\nmiddle of the chain also allows skipping the recheck for the first HOT\\nchain, which could improve scan performance a lot, especially in the\\nsecond variant that has no condition rechecks on invisible tuples.\\n\\nI don't really see how you'd do that on yours. You seem to assume\\nfinding a particular key-item pointer pair in an index would be\\nefficient, but IMHO that's not the case.\\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, 4 Aug 2016 23:53:05 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 11:53:05PM -0300, Claudio Freire wrote:\\n> The point is avoiding duplicate rows in the output of index scans.\\n> \\n> I don't think you can avoid it simply by applying index condition\\n> rechecks as the original proposal implies, in this case:\\n> \\n> CREATE TABLE t (id integer not null primary key, someid integer, dat integer);\\n> CREATE INDEX i1 ON t (someid);\\n> \\n> INSERT INTO t (id, someid, dat) VALUES (1, 2, 100);\\n\\nOK, let me run through this and you can tell me where I am wrong.\\n\\nAt this point there are two indexes, one on 'id' and one on 'someid'.\\n\\n> UPDATE t SET dat = dat + 1 where id = 1;\\n\\nThis is a HOT update because no indexes were changed.\\n\\n> UPDATE t SET dat = dat + 1, id = 2 where id = 1;\\n\\nThis changes the HOT chain to a WARM chain because one index is changed.\\nThat means that lookups on both indexes recheck the single visible\\ntuple, if there is one.\\n\\n> UPDATE t SET dat = dat + 1, id = 3, someid = 3 where id = 2;\\n\\nThis is ends the WARM chain, and creates new index entries because all\\nindexes are changed.\\n\\n> UPDATE t SET dat = dat + 1, id = 1, someid = 2 where id = 3;\\n\\nThis does the same thing.\\n\\n> SELECT * FROM t WHERE someid = 2;\\n\\nThis uses the 'someid' index. The index contains three entries:\\n\\n\\t1. {someid=2} pointing to first WARM chain\\n\\t2. {someid=3} pointing to single tuple (no HOT chain)\\n\\t3. {someid=2} pointing to single tuple (no HOT chain)\\n\\nThe scan of #1 returns no visible rows. #2 doesn't match the value in\\nthe WHERE clause, so we don't even check the heap. The scan of #3\\nreturns one row.\\n\\nRemember, we don't scan past the end of the HOT chain, which is what we\\ndo now.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 4 Aug 2016 23:44:23 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 12:44 AM, Bruce Momjian <bruce@momjian.us> wrote:\\n>> UPDATE t SET dat = dat + 1, id = 3, someid = 3 where id = 2;\\n>\\n> This is ends the WARM chain, and creates new index entries because all\\n> indexes are changed.\\n>\\n>> UPDATE t SET dat = dat + 1, id = 1, someid = 2 where id = 3;\\n>\\n> This does the same thing.\\n>\\n>> SELECT * FROM t WHERE someid = 2;\\n>\\n> This uses the 'someid' index. The index contains three entries:\\n>\\n> 1. {someid=2} pointing to first WARM chain\\n> 2. {someid=3} pointing to single tuple (no HOT chain)\\n> 3. {someid=2} pointing to single tuple (no HOT chain)\\n>\\n> The scan of #1 returns no visible rows. #2 doesn't match the value in\\n> the WHERE clause, so we don't even check the heap. The scan of #3\\n> returns one row.\\n>\\n> Remember, we don't scan past the end of the HOT chain, which is what we\\n> do now.\\n\\nOk, I botched the example.\\n\\nI wanted the other updates to all be WARM updates, so imagine there's\\nanother index that is unchanged (say, a someid2 not updated ever).\\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, 5 Aug 2016 00:59:01 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 8:23 AM, Claudio Freire <klaussfreire@gmail.com>\\nwrote:\\n\\n> On Thu, Aug 4, 2016 at 11:15 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n>\\n> >\\n> > OK, that's a lot of text, and I am confused. Please tell me the\\n> > advantage of having an index point to a string of HOT chains, rather\\n> > than a single one? Is the advantage that the index points into the\\n> > middle of the HOT chain rather than at the beginning? I can see some\\n> > value to that, but having more ctid HOT headers that can't be removed\\n> > except by VACUUM seems bad, plus the need for index rechecks as you\\n> > cross to the next HOT chain seems bad.\\n> >\\n> > The value of WARM is to avoid index bloat --- right now we traverse the\\n> > HOT chain on a single page just fine with no complaints about speed so I\\n> > don't see a value to optimizing that traversal, and I think the key\\n> > rechecks and ctid bloat will make it all much slower.\\n> >\\n> > It also seems much more complicated.\\n>\\n> The point is avoiding duplicate rows in the output of index scans.\\n>\\n> I don't think you can avoid it simply by applying index condition\\n> rechecks as the original proposal implies, in this case:\\n>\\n> CREATE TABLE t (id integer not null primary key, someid integer, dat\\n> integer);\\n> CREATE INDEX i1 ON t (someid);\\n>\\n> INSERT INTO t (id, someid, dat) VALUES (1, 2, 100);\\n> UPDATE t SET dat = dat + 1 where id = 1;\\n> UPDATE t SET dat = dat + 1, id = 2 where id = 1;\\n> UPDATE t SET dat = dat + 1, id = 3, someid = 3 where id = 2;\\n> UPDATE t SET dat = dat + 1, id = 1, someid = 2 where id = 3;\\n> SELECT * FROM t WHERE someid = 2;\\n>\\n> That, I believe, will cause the problematic chains where the condition\\n> recheck passes both times the last visible tuple is visited during the\\n> scan. It will return more than one tuple when in reality there is only\\n> one.\\n>\\n\\nHmm. That seems like a real problem. The only way to address that is to\\nensure that for a given WARM chain and given index key, there must exists\\nonly a single index entry. There can and will be multiple entries if the\\nindex key changes, but if the index key changes to the original value (or\\nany other value already in the WARM chain) again, we must not add another\\nindex entry. Now that does not seem like a very common scenario and\\nskipping a duplicate index entry does have its own benefit, so may be its\\nnot a terrible idea to try that. You're right, it may be expensive to\\nsearch for an existing matching index key for the same root line pointer.\\nBut if we could somehow short-circuit the more common case, it might still\\nbe worth trying.\\n\\nThe other idea you mentioned is to index intermediate tuples but somehow\\nrestrict WARM chain following knowing that the subsequent tuples are\\nreachable via different index tuple. I see two major problems with that\\napproach:\\n\\n1. When HOT or WARM chains are pruned and dead tuples removed, we may lose\\nthe knowledge about key changes between intermediate updates. Without that\\nits seems difficult to know when to stop while following chain starting\\nfrom the old index tuple.\\n\\n2. The existence of index pointers to intermediate tuples will lead to\\nindex bloat. This is the same problem that we found in Simon's original\\nproposal (discussed internally). None of the intermediate line pointers can\\nbe vacuumed until the entire chain becomes DEAD. Event if the a duplicate\\nindex key is inserted for every index, knowing that and reclaiming to the\\nindex pointers to the original root line pointer, will be difficult.\\n\\n\\n>\\n> Not to mention the cost of scanning the chain of N tuples N times,\\n> making it quadratic - bound by the number of tuples that can fit a\\n> page, but still high.\\n>\\n> Solving that, I believe, will remove all the simplicity of pointing to\\n> root tuples.\\n>\\n>\\nYou're right. But having all indexes point to the root line pointer makes\\nthings simpler to manage and less buggy. So if we can somehow solve the\\nduplicate tuples problem, even at additional cost at update time, it might\\nstill be worth. I would suggest that we should think more and we can find\\nsome solution to the problem.\\n\\n\\n>\\n> I don't really see how you'd do that on yours. You seem to assume\\n> finding a particular key-item pointer pair in an index would be\\n> efficient, but IMHO that's not the case.\\n>\\n\\nThat's true. But we could somehow short-circuit the more common pattern,\\nthat might still be worth. For corner cases, we can fall back to non-HOT\\nupdate and keep things simple. It will still be a huge improvement over\\nwhat we have currently.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Fri, Aug 5, 2016 at 8:23 AM, Claudio Freire <klaussfreire@gmail.com> wrote:On Thu, Aug 4, 2016 at 11:15 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n>\\n> OK, that's a lot of text, and I am confused. Please tell me the\\n> advantage of having an index point to a string of HOT chains, rather\\n> than a single one? Is the advantage that the index points into the\\n> middle of the HOT chain rather than at the beginning? I can see some\\n> value to that, but having more ctid HOT headers that can't be removed\\n> except by VACUUM seems bad, plus the need for index rechecks as you\\n> cross to the next HOT chain seems bad.\\n>\\n> The value of WARM is to avoid index bloat --- right now we traverse the\\n> HOT chain on a single page just fine with no complaints about speed so I\\n> don't see a value to optimizing that traversal, and I think the key\\n> rechecks and ctid bloat will make it all much slower.\\n>\\n> It also seems much more complicated.\\n\\nThe point is avoiding duplicate rows in the output of index scans.\\n\\nI don't think you can avoid it simply by applying index condition\\nrechecks as the original proposal implies, in this case:\\n\\nCREATE TABLE t (id integer not null primary key, someid integer, dat integer);\\nCREATE INDEX i1 ON t (someid);\\n\\nINSERT INTO t (id, someid, dat) VALUES (1, 2, 100);\\nUPDATE t SET dat = dat + 1 where id = 1;\\nUPDATE t SET dat = dat + 1, id = 2 where id = 1;\\nUPDATE t SET dat = dat + 1, id = 3, someid = 3 where id = 2;\\nUPDATE t SET dat = dat + 1, id = 1, someid = 2 where id = 3;\\nSELECT * FROM t WHERE someid = 2;\\n\\nThat, I believe, will cause the problematic chains where the condition\\nrecheck passes both times the last visible tuple is visited during the\\nscan. It will return more than one tuple when in reality there is only\\none.Hmm. That seems like a real problem. The only way to address that is to ensure that for a given WARM chain and given index key, there must exists only a single index entry. There can and will be multiple entries if the index key changes, but if the index key changes to the original value (or any other value already in the WARM chain) again, we must not add another index entry. Now that does not seem like a very common scenario and skipping a duplicate index entry does have its own benefit, so may be its not a terrible idea to try that. You're right, it may be expensive to search for an existing matching index key for the same root line pointer. But if we could somehow short-circuit the more common case, it might still be worth trying.The other idea you mentioned is to index intermediate tuples but somehow restrict WARM chain following knowing that the subsequent tuples are reachable via different index tuple. I see two major problems with that approach:1. When HOT or WARM chains are pruned and dead tuples removed, we may lose the knowledge about key changes between intermediate updates. Without that its seems difficult to know when to stop while following chain starting from the old index tuple.2. The existence of index pointers to intermediate tuples will lead to index bloat. This is the same problem that we found in Simon's original proposal (discussed internally). None of the intermediate line pointers can be vacuumed until the entire chain becomes DEAD. Event if the a duplicate index key is inserted for every index, knowing that and reclaiming to the index pointers to the original root line pointer, will be difficult. \\n\\nNot to mention the cost of scanning the chain of N tuples N times,\\nmaking it quadratic - bound by the number of tuples that can fit a\\npage, but still high.\\n\\nSolving that, I believe, will remove all the simplicity of pointing to\\nroot tuples.\\nYou're right. But having all indexes point to the root line pointer makes things simpler to manage and less buggy. So if we can somehow solve the duplicate tuples problem, even at additional cost at update time, it might still be worth. I would suggest that we should think more and we can find some solution to the problem. \\nI don't really see how you'd do that on yours. You seem to assume\\nfinding a particular key-item pointer pair in an index would be\\nefficient, but IMHO that's not the case.\\nThat's true. But we could somehow short-circuit the more common pattern, that might still be worth. For corner cases, we can fall back to non-HOT update and keep things simple. It will still be a huge improvement over what we have currently.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Fri, 5 Aug 2016 09:57:19 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 09:57:19AM +0530, Pavan Deolasee wrote:\\n> Hmm. That seems like a real problem. The only way to address that is to ensure\\n> that for a given WARM chain and given index key, there must exists only a\\n> single index entry. There can and will be multiple entries if the index key\\n> changes, but if the index key changes to the original value (or any other value\\n> already in the WARM chain) again, we must not add another index entry. Now that\\n> does not seem like a very common scenario and skipping a duplicate index entry\\n> does have its own benefit, so may be its not a terrible idea to try that.\\n> You're right, it may be expensive to search for an existing matching index key\\n> for the same root line pointer. But if we could somehow short-circuit the more\\n> common case, it might still be worth trying.\\n\\nI assumed that behavior was part of the original design; I stated\\nearlier:\\n\\n\\tAlso, what happens when a tuple chain goes off-page, then returns to the\\n\\toriginal page? That is a new HOT chain given our current code, but\\n\\twould the new tuple addition realize it needs to create a new index\\n\\ttuple? The new tuple code needs to check the index's root HOT tid for a\\n\\tnon-match.\\n\\nWe have to store the _head_ of the HOT/WARM chain in the index, not only\\nfor pruning, but so we can know if this HOT/WARM chain is already in the\\nindex and skip the index addition.\\n\\nI think modifying an index tuple is expensive, but checking an index and\\navoiding an addition should be quick.\\n\\n> The other idea you mentioned is to index intermediate tuples but somehow\\n> restrict WARM chain following knowing that the subsequent tuples are reachable\\n> via different index tuple. I see two major problems with that approach:\\n\\nI don't see much value of doing that, and a lot of complexity.\\n\\n> \\n> 1. When HOT or WARM chains are pruned and dead tuples removed, we may lose the\\n> knowledge about key changes between intermediate updates. Without that its\\n> seems difficult to know when to stop while following chain starting from the\\n> old index tuple.\\n> \\n> 2. The existence of index pointers to intermediate tuples will lead to index\\n> bloat. This is the same problem that we found in Simon's original proposal\\n> (discussed internally). None of the intermediate line pointers can be vacuumed\\n> until the entire chain becomes DEAD. Event if the a duplicate index key is\\n> inserted for every index, knowing that and reclaiming to the index pointers to\\n> the original root line pointer, will be difficult.\\n> �\\n> \\n> \\n> Not to mention the cost of scanning the chain of N tuples N times,\\n> making it quadratic - bound by the number of tuples that can fit a\\n> page, but still high.\\n> \\n> Solving that, I believe, will remove all the simplicity of pointing to\\n> root tuples.\\n> \\n> \\n> \\n> You're right. But having all indexes point to the root line pointer makes\\n> things simpler to manage and less buggy. So if we can somehow solve the\\n> duplicate tuples problem, even at additional cost at update time, it might\\n> still be worth. I would suggest that we should think more and we can find some\\n> solution to the problem.\\n\\nWhy is that hard? It seems simple to me as we just try to do the index\\ninsert, and skip it an entry for our key and ctid already exists.\\n\\n> I don't really see how you'd do that on yours. You seem to assume\\n> finding a particular key-item pointer pair in an index would be\\n> efficient, but IMHO that's not the case.\\n> \\n> \\n> That's true. But we could somehow short-circuit the more common pattern, that\\n> might still be worth. For corner cases, we can fall back to non-HOT update and\\n> keep things simple. It will still be a huge improvement over what we have\\n> currently.\\n\\nI don't see why it is hard. Trying to find the index entry for the old\\nupdate row seems odd, and updating an index row seems odd, but skipping\\nan index addition for the new row seems simple. Is the problem\\nconcurrent activity? I assumed already had that ability to add to HOT\\nchains because we have to lock the update chain.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 5 Aug 2016 09:52:25 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 1:27 AM, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:\\n>\\n>\\n> On Fri, Aug 5, 2016 at 8:23 AM, Claudio Freire <klaussfreire@gmail.com>\\n> wrote:\\n>>\\n>> On Thu, Aug 4, 2016 at 11:15 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n>>\\n>> >\\n>> > OK, that's a lot of text, and I am confused. Please tell me the\\n>> > advantage of having an index point to a string of HOT chains, rather\\n>> > than a single one? Is the advantage that the index points into the\\n>> > middle of the HOT chain rather than at the beginning? I can see some\\n>> > value to that, but having more ctid HOT headers that can't be removed\\n>> > except by VACUUM seems bad, plus the need for index rechecks as you\\n>> > cross to the next HOT chain seems bad.\\n>> >\\n>> > The value of WARM is to avoid index bloat --- right now we traverse the\\n>> > HOT chain on a single page just fine with no complaints about speed so I\\n>> > don't see a value to optimizing that traversal, and I think the key\\n>> > rechecks and ctid bloat will make it all much slower.\\n>> >\\n>> > It also seems much more complicated.\\n>>\\n>> The point is avoiding duplicate rows in the output of index scans.\\n>>\\n>> I don't think you can avoid it simply by applying index condition\\n>> rechecks as the original proposal implies, in this case:\\n>>\\n>> CREATE TABLE t (id integer not null primary key, someid integer, dat\\n>> integer);\\n>> CREATE INDEX i1 ON t (someid);\\n>>\\n>> INSERT INTO t (id, someid, dat) VALUES (1, 2, 100);\\n>> UPDATE t SET dat = dat + 1 where id = 1;\\n>> UPDATE t SET dat = dat + 1, id = 2 where id = 1;\\n>> UPDATE t SET dat = dat + 1, id = 3, someid = 3 where id = 2;\\n>> UPDATE t SET dat = dat + 1, id = 1, someid = 2 where id = 3;\\n>> SELECT * FROM t WHERE someid = 2;\\n>>\\n>> That, I believe, will cause the problematic chains where the condition\\n>> recheck passes both times the last visible tuple is visited during the\\n>> scan. It will return more than one tuple when in reality there is only\\n>> one.\\n>\\n>\\n> Hmm. That seems like a real problem. The only way to address that is to\\n> ensure that for a given WARM chain and given index key, there must exists\\n> only a single index entry. There can and will be multiple entries if the\\n> index key changes, but if the index key changes to the original value (or\\n> any other value already in the WARM chain) again, we must not add another\\n> index entry. Now that does not seem like a very common scenario and skipping\\n> a duplicate index entry does have its own benefit, so may be its not a\\n> terrible idea to try that. You're right, it may be expensive to search for\\n> an existing matching index key for the same root line pointer. But if we\\n> could somehow short-circuit the more common case, it might still be worth\\n> trying.\\n\\nI think it can be done. I could try to write a POC and see how it works.\\n\\n> The other idea you mentioned is to index intermediate tuples but somehow\\n> restrict WARM chain following knowing that the subsequent tuples are\\n> reachable via different index tuple. I see two major problems with that\\n> approach:\\n>\\n> 1. When HOT or WARM chains are pruned and dead tuples removed, we may lose\\n> the knowledge about key changes between intermediate updates. Without that\\n> its seems difficult to know when to stop while following chain starting from\\n> the old index tuple.\\n>\\n> 2. The existence of index pointers to intermediate tuples will lead to index\\n> bloat. This is the same problem that we found in Simon's original proposal\\n> (discussed internally). None of the intermediate line pointers can be\\n> vacuumed until the entire chain becomes DEAD. Event if the a duplicate index\\n> key is inserted for every index, knowing that and reclaiming to the index\\n> pointers to the original root line pointer, will be difficult.\\n\\nI don't see the difference it makes for bloat between storing the root\\ntid and the intermediate tid, but I haven't yet figured out how\\nvacuuming would work so maybe I have to think about that to realize\\nthe difference.\\n\\n>> Not to mention the cost of scanning the chain of N tuples N times,\\n>> making it quadratic - bound by the number of tuples that can fit a\\n>> page, but still high.\\n>>\\n>> Solving that, I believe, will remove all the simplicity of pointing to\\n>> root tuples.\\n>>\\n>\\n> You're right. But having all indexes point to the root line pointer makes\\n> things simpler to manage and less buggy. So if we can somehow solve the\\n> duplicate tuples problem, even at additional cost at update time, it might\\n> still be worth. I would suggest that we should think more and we can find\\n> some solution to the problem.\\n\\nWill try to go down that road and see what can be optimized.\\n\\n>> I don't really see how you'd do that on yours. You seem to assume\\n>> finding a particular key-item pointer pair in an index would be\\n>> efficient, but IMHO that's not the case.\\n>\\n>\\n> That's true. But we could somehow short-circuit the more common pattern,\\n> that might still be worth. For corner cases, we can fall back to non-HOT\\n> update and keep things simple. It will still be a huge improvement over what\\n> we have currently.\\n\\nWell, my proposed second variant can also work with root pointers, so\\nI believe that one should be viable. The only thing left is trying to\\noptimize duplicate path removal for the most common cases.\\n\\n\\nOn Fri, Aug 5, 2016 at 10:52 AM, Bruce Momjian <bruce@momjian.us> wrote:\\n>> I don't really see how you'd do that on yours. You seem to assume\\n>> finding a particular key-item pointer pair in an index would be\\n>> efficient, but IMHO that's not the case.\\n>>\\n>>\\n>> That's true. But we could somehow short-circuit the more common pattern, that\\n>> might still be worth. For corner cases, we can fall back to non-HOT update and\\n>> keep things simple. It will still be a huge improvement over what we have\\n>> currently.\\n>\\n> I don't see why it is hard. Trying to find the index entry for the old\\n> update row seems odd, and updating an index row seems odd, but skipping\\n> an index addition for the new row seems simple. Is the problem\\n> concurrent activity? I assumed already had that ability to add to HOT\\n> chains because we have to lock the update chain.\\n\\n\\nThink of an index over a 1TB table whose keys have only 2 values: true\\nand false.\\n\\nSure, it's a horrible index. But I've seen things like that, and I've\\nseen cases when they're useful too.\\n\\nSo, conceptually, for each key you have circa N/2 tids on the index.\\nnbtree finds the leftmost valid insert point comparing keys, it\\ndoesn't care about tids, so to find the index entries that point to\\nthe page where the new tuple is, you'd have to scan the N/2 tids in\\nthe index, an extremely expensive operation.\\n\\nInsert is fast, because you just have to add a tid somewhere in that\\nrange, if you want to find a specific tid, it's a wholly different\\nstory.\\n\\nAnd that's only for nbtree, other indexams may have their own perks.\\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, 5 Aug 2016 12:25:39 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 12:25:39PM -0300, Claudio Freire wrote:\\n> > 2. The existence of index pointers to intermediate tuples will lead to index\\n> > bloat. This is the same problem that we found in Simon's original proposal\\n> > (discussed internally). None of the intermediate line pointers can be\\n> > vacuumed until the entire chain becomes DEAD. Event if the a duplicate index\\n> > key is inserted for every index, knowing that and reclaiming to the index\\n> > pointers to the original root line pointer, will be difficult.\\n> \\n> I don't see the difference it makes for bloat between storing the root\\n> tid and the intermediate tid, but I haven't yet figured out how\\n> vacuuming would work so maybe I have to think about that to realize\\n> the difference.\\n\\nThink of page pruning --- we can't remove a ctid that an index points\\nto. The more ctids you point to in a HOT chain, the fewer ctids you can\\nremove --- that's why we want to point only to the head of the HOT/WARM\\nchain.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 5 Aug 2016 11:45:16 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 8:55 PM, Claudio Freire <klaussfreire@gmail.com>\\nwrote:\\n\\n> On Fri, Aug 5, 2016 at 1:27 AM, Pavan Deolasee <pavan.deolasee@gmail.com>\\n> wrote:\\n> >\\n> >\\n> > I don't see why it is hard. Trying to find the index entry for the old\\n> > update row seems odd, and updating an index row seems odd, but skipping\\n> > an index addition for the new row seems simple. Is the problem\\n> > concurrent activity? I assumed already had that ability to add to HOT\\n> > chains because we have to lock the update chain.\\n>\\n>\\n> Think of an index over a 1TB table whose keys have only 2 values: true\\n> and false.\\n>\\n> Sure, it's a horrible index. But I've seen things like that, and I've\\n> seen cases when they're useful too.\\n>\\n> So, conceptually, for each key you have circa N/2 tids on the index.\\n> nbtree finds the leftmost valid insert point comparing keys, it\\n> doesn't care about tids, so to find the index entries that point to\\n> the page where the new tuple is, you'd have to scan the N/2 tids in\\n> the index, an extremely expensive operation.\\n>\\n>\\nWell, it's always going to be extremely hard to solve for all use cases.\\nThis is one such extreme case and we should just give up and do cold\\nupdate.\\n\\nI think we can look at the index type (unique vs non-unique) along with\\ntable statistics to find what fraction of column values are distinct and\\nthen estimate whether its worthwhile to look for duplicate (key, CTID) or\\njust do a cold update. In addition put some cap of how hard we try once we\\ndecide to check for duplicates and give up after we cross that threshold.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Fri, Aug 5, 2016 at 8:55 PM, Claudio Freire <klaussfreire@gmail.com> wrote:On Fri, Aug 5, 2016 at 1:27 AM, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:\\n>\\n>\\n> I don't see why it is hard. Trying to find the index entry for the old\\n> update row seems odd, and updating an index row seems odd, but skipping\\n> an index addition for the new row seems simple. Is the problem\\n> concurrent activity? I assumed already had that ability to add to HOT\\n> chains because we have to lock the update chain.\\n\\n\\nThink of an index over a 1TB table whose keys have only 2 values: true\\nand false.\\n\\nSure, it's a horrible index. But I've seen things like that, and I've\\nseen cases when they're useful too.\\n\\nSo, conceptually, for each key you have circa N/2 tids on the index.\\nnbtree finds the leftmost valid insert point comparing keys, it\\ndoesn't care about tids, so to find the index entries that point to\\nthe page where the new tuple is, you'd have to scan the N/2 tids in\\nthe index, an extremely expensive operation.\\nWell, it's always going to be extremely hard to solve for all use cases. This is one such extreme case and we should just give up and do cold update. I think we can look at the index type (unique vs non-unique) along with table statistics to find what fraction of column values are distinct and then estimate whether its worthwhile to look for duplicate (key, CTID) or just do a cold update. In addition put some cap of how hard we try once we decide to check for duplicates and give up after we cross that threshold.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Fri, 5 Aug 2016 22:56:49 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 2:26 PM, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:\\n> On Fri, Aug 5, 2016 at 8:55 PM, Claudio Freire <klaussfreire@gmail.com>\\n> wrote:\\n>>\\n>> On Fri, Aug 5, 2016 at 1:27 AM, Pavan Deolasee <pavan.deolasee@gmail.com>\\n>> wrote:\\n>> >\\n>> >\\n>> > I don't see why it is hard. Trying to find the index entry for the old\\n>> > update row seems odd, and updating an index row seems odd, but skipping\\n>> > an index addition for the new row seems simple. Is the problem\\n>> > concurrent activity? I assumed already had that ability to add to HOT\\n>> > chains because we have to lock the update chain.\\n>>\\n>>\\n>> Think of an index over a 1TB table whose keys have only 2 values: true\\n>> and false.\\n>>\\n>> Sure, it's a horrible index. But I've seen things like that, and I've\\n>> seen cases when they're useful too.\\n>>\\n>> So, conceptually, for each key you have circa N/2 tids on the index.\\n>> nbtree finds the leftmost valid insert point comparing keys, it\\n>> doesn't care about tids, so to find the index entries that point to\\n>> the page where the new tuple is, you'd have to scan the N/2 tids in\\n>> the index, an extremely expensive operation.\\n>>\\n>\\n> Well, it's always going to be extremely hard to solve for all use cases.\\n> This is one such extreme case and we should just give up and do cold update.\\n>\\n> I think we can look at the index type (unique vs non-unique) along with\\n> table statistics to find what fraction of column values are distinct and\\n> then estimate whether its worthwhile to look for duplicate (key, CTID) or\\n> just do a cold update. In addition put some cap of how hard we try once we\\n> decide to check for duplicates and give up after we cross that threshold.\\n\\nI don't think bailing out in this case is necessary, and it could be\\nmore common than you'd think. It doesn't need to be this extreme to\\ncause the issue, it only needs equal-key runs that span more than an\\nindex page, and that could be far more common than the extreme example\\nI gave.\\n\\nBut doing the WARM chain backtracking and checking for previous\\nversions with appropriate keys should be enough to support this use\\ncase too, it just needs to be well optimized to avoid seriously\\nimpacting performance on the average case.\\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, 5 Aug 2016 14:43:37 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 02:43:37PM -0300, Claudio Freire wrote:\\n> But doing the WARM chain backtracking and checking for previous\\n> versions with appropriate keys should be enough to support this use\\n> case too, it just needs to be well optimized to avoid seriously\\n> impacting performance on the average case.\\n\\nYes, that was an idea I had to --- if the in-page HOT chain already has\\nthe key, we know it is already in the index and we can skip the index\\naddition.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 5 Aug 2016 13:56:55 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 11:26 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n\\n> On Fri, Aug 5, 2016 at 02:43:37PM -0300, Claudio Freire wrote:\\n> > But doing the WARM chain backtracking and checking for previous\\n> > versions with appropriate keys should be enough to support this use\\n> > case too, it just needs to be well optimized to avoid seriously\\n> > impacting performance on the average case.\\n>\\n> Yes, that was an idea I had to --- if the in-page HOT chain already has\\n> the key, we know it is already in the index and we can skip the index\\n> addition.\\n>\\n>\\nI just don't know how would you do that without delaying/not-doing HOT\\nchain prune. As soon as root and intermediate HOT tuples are gone, all\\ninformation is lost. You may delay that, but that will defeat the whole\\npurpose. If chains are not pruned in-time, you may not find any free space\\nin the page and end up doing a cold update anyways. But may be I am missing\\nsomething and Claudio has a different idea.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Fri, Aug 5, 2016 at 11:26 PM, Bruce Momjian <bruce@momjian.us> wrote:On Fri, Aug 5, 2016 at 02:43:37PM -0300, Claudio Freire wrote:\\n> But doing the WARM chain backtracking and checking for previous\\n> versions with appropriate keys should be enough to support this use\\n> case too, it just needs to be well optimized to avoid seriously\\n> impacting performance on the average case.\\n\\nYes, that was an idea I had to --- if the in-page HOT chain already has\\nthe key, we know it is already in the index and we can skip the index\\naddition.\\n\\nI just don't know how would you do that without delaying/not-doing HOT chain prune. As soon as root and intermediate HOT tuples are gone, all information is lost. You may delay that, but that will defeat the whole purpose. If chains are not pruned in-time, you may not find any free space in the page and end up doing a cold update anyways. But may be I am missing something and Claudio has a different idea.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Fri, 5 Aug 2016 23:30:26 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 11:30:26PM +0530, Pavan Deolasee wrote:\\n> On Fri, Aug 5, 2016 at 11:26 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n> \\n> On Fri, Aug� 5, 2016 at 02:43:37PM -0300, Claudio Freire wrote:\\n> > But doing the WARM chain backtracking and checking for previous\\n> > versions with appropriate keys should be enough to support this use\\n> > case too, it just needs to be well optimized to avoid seriously\\n> > impacting performance on the average case.\\n> \\n> Yes, that was an idea I had to --- if the in-page HOT chain already has\\n> the key, we know it is already in the index and we can skip the index\\n> addition.\\n> \\n> I just don't know how would you do that without delaying/not-doing HOT chain\\n> prune. As soon as root and intermediate HOT tuples are gone, all information is\\n> lost. You may delay that, but that will defeat the whole purpose. If chains are\\n> not pruned in-time, you may not find any free space in the page and end up\\n> doing a cold update anyways. But may be I am missing something and Claudio has\\n> a different idea.\\n\\nYes, pruning would be a problem. :-(\\n\\nA check only needs to happen when the indexed key changes, right? So we\\nare comparing the cost of adding an index key vs. the cost of trying to\\nfind a matching key/ctid in the index. Seems the later is cheaper, but\\nit is not obvious.\\n\\nI think I see Claudio's idea now --- from his diagram, you can have WARM\\nchains span multiple HOT chains. What he is doing is creating a new HOT\\nchain everytime _any_ key changes, and he knows the entire HOT chain has\\nidential values for all indexes. He moves from one HOT chain to another\\nduring an index scan by checking if the index value is the same in the\\nold and new HOT chain (that is the same WARM chain).\\n\\nThis does create more HOT chains where the root ctid cannot be removed,\\nbut it does avoid the index key/ctid check because any entry in the HOT\\nchain has identical keys. What this would not handle is when an entire\\nHOT chain is pruned, as the keys would be gone.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 5 Aug 2016 15:26:15 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 03:26:15PM -0400, Bruce Momjian wrote:\\n> > I just don't know how would you do that without delaying/not-doing HOT chain\\n> > prune. As soon as root and intermediate HOT tuples are gone, all information is\\n> > lost. You may delay that, but that will defeat the whole purpose. If chains are\\n> > not pruned in-time, you may not find any free space in the page and end up\\n> > doing a cold update anyways. But may be I am missing something and Claudio has\\n> > a different idea.\\n> \\n> Yes, pruning would be a problem. :-(\\n> \\n> A check only needs to happen when the indexed key changes, right? So we\\n> are comparing the cost of adding an index key vs. the cost of trying to\\n> find a matching key/ctid in the index. Seems the later is cheaper, but\\n> it is not obvious.\\n\\nHere is an illustration of the issue:\\n\\n\\tCREATE TABLE test (col1 INTEGER, col2 INTEGER, col3 INTEGER);\\n\\t\\n\\t-- index first two columns\\n\\tCREATE INDEX i_test1 ON test (col1);\\n\\tCREATE INDEX i_test2 ON test (col2);\\n\\t\\n\\tINSERT INTO test VALUES (1, 7, 20);\\n\\t\\n\\t-- create a HOT chain\\n\\tUPDATE test SET col3 = 30;\\n\\t\\n\\t-- change the HOT chain to a WARM chain, changes i_test2 but not i_test1\\n\\tUPDATE test SET col2 = 8;\\n\\t\\n\\t-- we should avoid adding a col2=7 i_test2 index tuple\\n\\t-- because we already have one; how do we know that?\\n\\tUPDATE test SET col2 = 7;\\n\\t\\n\\t-- we should see only one col2=7 i_test2 index tuple\\n\\tSELECT * FROM test WHERE col2 = 7;\\n\\t col1 | col2 | col3\\n\\t------+------+------\\n\\t 1 | 7 | 30\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 5 Aug 2016 18:20:50 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 4:26 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n> On Fri, Aug 5, 2016 at 11:30:26PM +0530, Pavan Deolasee wrote:\\n>> On Fri, Aug 5, 2016 at 11:26 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n>>\\n>> On Fri, Aug 5, 2016 at 02:43:37PM -0300, Claudio Freire wrote:\\n>> > But doing the WARM chain backtracking and checking for previous\\n>> > versions with appropriate keys should be enough to support this use\\n>> > case too, it just needs to be well optimized to avoid seriously\\n>> > impacting performance on the average case.\\n>>\\n>> Yes, that was an idea I had to --- if the in-page HOT chain already has\\n>> the key, we know it is already in the index and we can skip the index\\n>> addition.\\n>>\\n>> I just don't know how would you do that without delaying/not-doing HOT chain\\n>> prune. As soon as root and intermediate HOT tuples are gone, all information is\\n>> lost. You may delay that, but that will defeat the whole purpose. If chains are\\n>> not pruned in-time, you may not find any free space in the page and end up\\n>> doing a cold update anyways. But may be I am missing something and Claudio has\\n>> a different idea.\\n>\\n> Yes, pruning would be a problem. :-(\\n>\\n> A check only needs to happen when the indexed key changes, right? So we\\n> are comparing the cost of adding an index key vs. the cost of trying to\\n> find a matching key/ctid in the index. Seems the later is cheaper, but\\n> it is not obvious.\\n>\\n> I think I see Claudio's idea now --- from his diagram, you can have WARM\\n> chains span multiple HOT chains. What he is doing is creating a new HOT\\n> chain everytime _any_ key changes, and he knows the entire HOT chain has\\n> idential values for all indexes. He moves from one HOT chain to another\\n> during an index scan by checking if the index value is the same in the\\n> old and new HOT chain (that is the same WARM chain).\\n>\\n> This does create more HOT chains where the root ctid cannot be removed,\\n> but it does avoid the index key/ctid check because any entry in the HOT\\n> chain has identical keys. What this would not handle is when an entire\\n> HOT chain is pruned, as the keys would be gone.\\n\\nI believe the only solution is to use bitmap index scans with WARM indexes.\\n\\nDoing so simplifies things considerably.\\n\\nFor one, it isolates the new functionality and makes it opt-in.\\n\\nThen, WARM indexes can always point to the root of the HOT chain, and\\nbe ignored for satisfies HOT. The planner will only consider bitmap\\nindex scans with WARM indexes, and always issue a recheck.\\n\\nThe bitmap is needed to remove duplicate item pointers, and the\\nrecheck, as usual, to filter out unwanted versions.\\n\\nOn update, one only needs a pointer to the HOT head, which would\\narguably be at hand, or at worst reachable by backtracking t_ctid\\npointers. No key checks of any kind, and no weird flags required.\\n\\nI don't see another solution to the information loss when pruning\\nwhole HOT chains.\\n\\nSuppose we start with this situation:\\n\\nlp: 1 2h 3h 4w 5h 6h 7h\\nk1: a a a b b a a\\nk2: c c c c c c c\\n\\nSo we have 2 HOT chains, 1-3, 4-7, two indexes, one never updated, the\\nother with an update and then returning to the same key.\\n\\nThe first index will have two index entries, one for key a, another\\nfor b, both pointing at 1.\\n\\na -> (p,1)\\nb -> (p,1)\\n\\nNow versions 1-3 are dead, so we want to prune them.\\n\\nWe end up with a redirect on the LP for 1 -> 4, LPs 2 and 3 unused\\nbecause they were HOT\\n\\n r4 u u\\nlp: 1 2 3 4w 5h 6 7h\\nk1: _ _ _ b b a a\\nk2: _ _ _ c c c c\\n\\nNow suppose versions 4 and 5 die. So we end up with:\\n\\n r6 u u u u\\nlp: 1 2 3 4 5 6 7h\\nk1: _ _ _ _ _ a a\\nk2: _ _ _ _ _ c c\\n\\nWe just forgot that \\\"b\\\" was in k1, yet we still have an index entry\\npointing to the chain.\\n\\nShould an update come:\\n\\n r6 u u u u\\nlp: 1 2 3 4 5 6 7h 8?\\nk1: _ _ _ _ _ a a b\\nk2: _ _ _ _ _ c c c\\n\\nIs an index entry b->(p,1) needed for 8?\\n\\nAccording to the logic, it is, k1 would need a new entry b -> (p,1),\\nbut the entry is already there. It's just unverifiable in reasonable\\ntime.\\n\\nSo a simpler solution is to always add such entries, and let the\\nbitmap index scan filter duplicates.\\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, 5 Aug 2016 19:51:05 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 07:51:05PM -0300, Claudio Freire wrote:\\n> > This does create more HOT chains where the root ctid cannot be removed,\\n> > but it does avoid the index key/ctid check because any entry in the HOT\\n> > chain has identical keys. What this would not handle is when an entire\\n> > HOT chain is pruned, as the keys would be gone.\\n> \\n> I believe the only solution is to use bitmap index scans with WARM indexes.\\n\\nLet me back up and explain the benefits we get from allowing HOT chains\\nto be WARM:\\n\\n* no index entries for WARM indexes whose values don't change\\n* improved pruning because the HOT/WARM chains can be longer because we\\n don't have to break chains for index changes\\n\\nWhile I realize bitmap indexes would allow us to remove duplicate index\\nentries, it removes one of the two benefits of WARM, and it causes every\\nindex read to be expensive --- I can't see how this would be a win over\\ndoing the index check on writes.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 5 Aug 2016 20:07:18 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 9:07 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n> On Fri, Aug 5, 2016 at 07:51:05PM -0300, Claudio Freire wrote:\\n>> > This does create more HOT chains where the root ctid cannot be removed,\\n>> > but it does avoid the index key/ctid check because any entry in the HOT\\n>> > chain has identical keys. What this would not handle is when an entire\\n>> > HOT chain is pruned, as the keys would be gone.\\n>>\\n>> I believe the only solution is to use bitmap index scans with WARM indexes.\\n>\\n> Let me back up and explain the benefits we get from allowing HOT chains\\n> to be WARM:\\n>\\n> * no index entries for WARM indexes whose values don't change\\n> * improved pruning because the HOT/WARM chains can be longer because we\\n> don't have to break chains for index changes\\n>\\n> While I realize bitmap indexes would allow us to remove duplicate index\\n> entries, it removes one of the two benefits of WARM, and it causes every\\n> index read to be expensive --- I can't see how this would be a win over\\n> doing the index check on writes.\\n\\nBut the index check could be prohibitely expensive.\\n\\nSo we're back to bailing out?\\n\\nWhen an update comes and we're considering WARM, we need to query the\\nindexes, each one, and if one index cannot quickly verify the\\nexistence of an entry for the root tid for the key, bail out from\\nWARM.\\n\\nThat may prevent the benefits of WARM in a lot of real world cases.\\nYou just need one less-than-unique index to disable WARM for all\\nupdates, and IIRC those are common. You'd pay the CPU price of WARM\\nwithout any of the benefits.\\n\\nI don't think I have a single table in my databases that don't exhibit\\nthis behavior.\\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, 5 Aug 2016 21:21:49 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 9:21 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> On Fri, Aug 5, 2016 at 9:07 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n>> On Fri, Aug 5, 2016 at 07:51:05PM -0300, Claudio Freire wrote:\\n>>> > This does create more HOT chains where the root ctid cannot be removed,\\n>>> > but it does avoid the index key/ctid check because any entry in the HOT\\n>>> > chain has identical keys. What this would not handle is when an entire\\n>>> > HOT chain is pruned, as the keys would be gone.\\n>>>\\n>>> I believe the only solution is to use bitmap index scans with WARM indexes.\\n>>\\n>> Let me back up and explain the benefits we get from allowing HOT chains\\n>> to be WARM:\\n>>\\n>> * no index entries for WARM indexes whose values don't change\\n>> * improved pruning because the HOT/WARM chains can be longer because we\\n>> don't have to break chains for index changes\\n>>\\n>> While I realize bitmap indexes would allow us to remove duplicate index\\n>> entries, it removes one of the two benefits of WARM, and it causes every\\n>> index read to be expensive --- I can't see how this would be a win over\\n>> doing the index check on writes.\\n>\\n> But the index check could be prohibitely expensive.\\n\\nWell... it could be made efficient for the case of nbtree with a format change.\\n\\nIf nbtree sorted by tid as well, for instance.\\n\\nBut an upgrade there would involve a reindex before WARM can be applied.\\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, 5 Aug 2016 21:26:35 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 09:21:49PM -0300, Claudio Freire wrote:\\n> On Fri, Aug 5, 2016 at 9:07 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n> > On Fri, Aug 5, 2016 at 07:51:05PM -0300, Claudio Freire wrote:\\n> >> > This does create more HOT chains where the root ctid cannot be removed,\\n> >> > but it does avoid the index key/ctid check because any entry in the HOT\\n> >> > chain has identical keys. What this would not handle is when an entire\\n> >> > HOT chain is pruned, as the keys would be gone.\\n> >>\\n> >> I believe the only solution is to use bitmap index scans with WARM indexes.\\n> >\\n> > Let me back up and explain the benefits we get from allowing HOT chains\\n> > to be WARM:\\n> >\\n> > * no index entries for WARM indexes whose values don't change\\n> > * improved pruning because the HOT/WARM chains can be longer because we\\n> > don't have to break chains for index changes\\n> >\\n> > While I realize bitmap indexes would allow us to remove duplicate index\\n> > entries, it removes one of the two benefits of WARM, and it causes every\\n> > index read to be expensive --- I can't see how this would be a win over\\n> > doing the index check on writes.\\n> \\n> But the index check could be prohibitely expensive.\\n\\nTrue, but I am afraid the bitmap handling on reads will be worse.\\n\\n> So we're back to bailing out?\\n> \\n> When an update comes and we're considering WARM, we need to query the\\n> indexes, each one, and if one index cannot quickly verify the\\n> existence of an entry for the root tid for the key, bail out from\\n> WARM.\\n\\nYes, it seems we either find the entry fast and avoid the index\\naddition, or don't find it quickly and use a non-HOT, non-WARM update.\\nThe problem is that you have to do this for multiple indexes, and if you\\nquickly find you need to add an entry to the first index, when you get\\nto the second one you can't easily bail out and go with a non-HOT,\\nnon-WARM update. I suppose we could bail out of a long index search if\\nthere is only one index with a changed key.\\n\\nHere's how I underestand it --- if you are looking for a key that has\\nonly a few index entries, it will be fast to find of the key/ctid is\\nlisted. If the index has many index entries for the key, it will be\\nexpensive to find if there is a matching key/ctid, but a read-only-query\\nindex lookup for that key will be expensive too, whether you use the\\nbitmap scan or not. And, effectively, if we bail out and decide to go\\nwith a non-HOT, non-WARM update, we are making the index even bigger.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 5 Aug 2016 21:02:39 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 09:02:39PM -0400, Bruce Momjian wrote:\\n> Yes, it seems we either find the entry fast and avoid the index\\n> addition, or don't find it quickly and use a non-HOT, non-WARM update.\\n> The problem is that you have to do this for multiple indexes, and if you\\n> quickly find you need to add an entry to the first index, when you get\\n> to the second one you can't easily bail out and go with a non-HOT,\\n> non-WARM update. I suppose we could bail out of a long index search if\\n> there is only one index with a changed key.\\n> \\n> Here's how I understand it --- if you are looking for a key that has\\n> only a few index entries, it will be fast to find of the key/ctid is\\n> listed. If the index has many index entries for the key, it will be\\n> expensive to find if there is a matching key/ctid, but a read-only-query\\n> index lookup for that key will be expensive too, whether you use the\\n> bitmap scan or not. And, effectively, if we bail out and decide to go\\n> with a non-HOT, non-WARM update, we are making the index even bigger.\\n\\nSo to summarize again:\\n\\no chains start out as HOT\\no they become WARM when some indexes change and others don't\\no for multiple index changes, we have to check all indexes\\n for key/ctid matches\\no for single index changes, we can fail HOT and create a new\\n non-HOT/WARM tuple if there are too many index matches\\no 99% of index checks will not find a key/ctid match\\n\\nI am not sure how to optimize an index non-match.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 5 Aug 2016 21:40:35 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 09:40:35PM -0400, Bruce Momjian wrote:\\n> So to summarize again:\\n> \\n> o chains start out as HOT\\n> o they become WARM when some indexes change and others don't\\n> o for multiple index changes, we have to check all indexes\\n> for key/ctid matches\\n> o for single index changes, we can fail HOT and create a new\\n> non-HOT/WARM tuple if there are too many index matches\\n> o 99% of index checks will not find a key/ctid match\\n\\nI think a WARM chain where the the head ctid isn't LP_REDIRECT wasn't\\npruned, so here is an updated list:\\n\\no chains start out as HOT\\no they become WARM when some indexes change and others don't\\no if WARM chain head is not LP_REDIRECT, check existing chain for key\\n matches\\no if WARM chain head is LP_REDIRECT:\\n\\to for single index changes, we can fail HOT and create a new\\n\\t non-HOT/WARM tuple if there are too many index matches\\n\\to for multiple index changes, we have to check all indexes\\n\\t for key/ctid matches\\n\\to 99% of index checks will not find a key/ctid match\\n\\nSo, we are only checking the index if the WARM chain was pruned, and we\\ncan bail out if there is only one index changed. This is looking more\\ndoable.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 5 Aug 2016 23:04:33 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Sat, Aug 6, 2016 at 8:34 AM, Bruce Momjian <bruce@momjian.us> wrote:\\n\\n> On Fri, Aug 5, 2016 at 09:40:35PM -0400, Bruce Momjian wrote:\\n> > So to summarize again:\\n> >\\n> > o chains start out as HOT\\n> > o they become WARM when some indexes change and others don't\\n> > o for multiple index changes, we have to check all indexes\\n> > for key/ctid matches\\n> > o for single index changes, we can fail HOT and create a new\\n> > non-HOT/WARM tuple if there are too many index matches\\n> > o 99% of index checks will not find a key/ctid match\\n>\\n> I think a WARM chain where the the head ctid isn't LP_REDIRECT wasn't\\n> pruned, so here is an updated list:\\n>\\n> o chains start out as HOT\\n> o they become WARM when some indexes change and others don't\\n> o if WARM chain head is not LP_REDIRECT, check existing chain for key\\n> matches\\n> o if WARM chain head is LP_REDIRECT:\\n> o for single index changes, we can fail HOT and create a new\\n> non-HOT/WARM tuple if there are too many index matches\\n> o for multiple index changes, we have to check all indexes\\n> for key/ctid matches\\n> o 99% of index checks will not find a key/ctid match\\n>\\n> So, we are only checking the index if the WARM chain was pruned, and we\\n> can bail out if there is only one index changed. This is looking more\\n> doable.\\n\\n\\nThe duplicate tuples problem that we are focusing on, happens when an index\\nalready has two or index tuples pointing to the same root tuple/lp. When\\nit's time to insert third index tuple, we must not insert a duplicate (key,\\nCTID) tuple. I've a design where we can track which columns (we are\\ninterested only in the columns on which indexes use) were ever changed in\\nthe WARM chain. We allow one change for every index column, but the second\\nchange will require a duplicate lookup. This is still quite an improvement,\\nthe cold updates may reduce by at least more than 50% already, but someone\\ncan argue that this does not handle the case where same index column is\\nrepeatedly updated.\\n\\nIf we need to find an efficient way to convert WARM chains back to HOT,\\nwhich will happen soon when the old index tuple retires, the system can\\nattain a stable state, not for all but many use cases.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Sat, Aug 6, 2016 at 8:34 AM, Bruce Momjian <bruce@momjian.us> wrote:On Fri, Aug 5, 2016 at 09:40:35PM -0400, Bruce Momjian wrote:\\n> So to summarize again:\\n>\\n> o chains start out as HOT\\n> o they become WARM when some indexes change and others don't\\n> o for multiple index changes, we have to check all indexes\\n> for key/ctid matches\\n> o for single index changes, we can fail HOT and create a new\\n> non-HOT/WARM tuple if there are too many index matches\\n> o 99% of index checks will not find a key/ctid match\\n\\nI think a WARM chain where the the head ctid isn't LP_REDIRECT wasn't\\npruned, so here is an updated list:\\n\\no chains start out as HOT\\no they become WARM when some indexes change and others don't\\no if WARM chain head is not LP_REDIRECT, check existing chain for key\\n matches\\no if WARM chain head is LP_REDIRECT:\\n o for single index changes, we can fail HOT and create a new\\n non-HOT/WARM tuple if there are too many index matches\\n o for multiple index changes, we have to check all indexes\\n for key/ctid matches\\n o 99% of index checks will not find a key/ctid match\\n\\nSo, we are only checking the index if the WARM chain was pruned, and we\\ncan bail out if there is only one index changed. This is looking more\\ndoable.The duplicate tuples problem that we are focusing on, happens when an index already has two or index tuples pointing to the same root tuple/lp. When it's time to insert third index tuple, we must not insert a duplicate (key, CTID) tuple. I've a design where we can track which columns (we are interested only in the columns on which indexes use) were ever changed in the WARM chain. We allow one change for every index column, but the second change will require a duplicate lookup. This is still quite an improvement, the cold updates may reduce by at least more than 50% already, but someone can argue that this does not handle the case where same index column is repeatedly updated.If we need to find an efficient way to convert WARM chains back to HOT, which will happen soon when the old index tuple retires, the system can attain a stable state, not for all but many use cases.Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Sat, 6 Aug 2016 10:08:47 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Sat, Aug 6, 2016 at 10:08:47AM +0530, Pavan Deolasee wrote:\\n> So, we are only checking the index if the WARM chain was pruned, and we\\n> can bail out if there is only one index changed.� This is looking more\\n> doable.\\n> \\n> \\n> The duplicate tuples problem that we are focusing on, happens when an index\\n> already has two or index tuples pointing to the same root tuple/lp. When it's\\n> time to insert third index tuple, we must not insert a duplicate (key, CTID)\\n> tuple. I've a design where we can track which columns (we are interested only\\n> in the columns on which indexes use) were ever changed in the WARM chain. We\\n> allow one change for every index column, but the second change will require a\\n> duplicate lookup. This is still quite an improvement, the cold updates may\\n> reduce by at least more than 50% already, but someone can argue that this does\\n> not handle the case where same index column is repeatedly updated.\\n\\nYes, I was thinking of that too. We can use LP_REDIRECT ctid's lp_len,\\nwhich is normally all zeros and has 15 unused bits, to record which of\\nthe first 15 columns have been had changed tuples pruned. A simpler\\nidea would be to use just one bit to record if WARM tuples have been\\npruned, because if we prune HOT tuples, we can still traverse the chain.\\n\\nA more serious concern is index creation. If we already have a WARM\\nchain and create an index, we can't assume that all indexes will have\\nentries for change in the WARM chain. One fix would be for index\\ncreation to walk warm chains and and add index entries for all changed\\ncolumns. We don't need to that now because we assume the index will\\nonly be used by new transactions that can't see the old chain. Another\\nidea would be to look at the index xmin and determine if the index was\\nrecording tuples in the chain.\\n\\n(FYI, in your idea above, I don't think you can track which _indexes_\\nhad changes because index creation will need to know information on\\ncolumn changes that weren't recorded at WARM chain creation time, hence\\nI am tracking column changes, not index changes.)\\n\\nAnother issue is that while index walking is usually fast, there are\\npathological cases. For example, if a column value is 80% of all rows,\\nthe optimizer would use statistics to avoid using the index for that\\nconstant, but if someone changes a WARM chain to use that value, we\\nwould need to read 80% of the index to find if the key/ctid exists, and\\nin most cases it will not, so we have to read the entire thing.\\n\\nWe do have the fallback to create a non-HOT, non-WARM tuple for this\\ncase for single-index changes.\\n\\n> If we need to find an efficient way to convert WARM chains back to HOT, which\\n> will happen soon when the old index tuple retires, the system can attain a\\n> stable state, not for all but many use cases.\\n\\nI don't see how that is possible, except perhaps by vacuum.\\n\\nOK, now I am less certain.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 6 Aug 2016 10:51:21 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Sat, Aug 6, 2016 at 10:51:21AM -0400, Bruce Momjian wrote:\\n> > If we need to find an efficient way to convert WARM chains back to HOT, which\\n> > will happen soon when the old index tuple retires, the system can attain a\\n> > stable state, not for all but many use cases.\\n> \\n> I don't see how that is possible, except perhaps by vacuum.\\n> \\n> OK, now I am less certain.\\n\\nOK, crazy idea time --- what if we only do WARM chain additions when all\\nindexed values are increasing (with NULLs higher than all values)? (If\\na key is always-increasing, it can't match a previous value in the\\nchain.) That avoids the problem of having to check the WARM chain,\\nexcept for the previous tuple, and the problem of pruning removing\\nchanged rows. It avoids having to check the index for matching key/ctid\\nvalues, and it prevents CREATE INDEX from having to index WARM chain\\nvalues.\\n\\nAny decreasing value would cause a normal tuple be created.\\n\\nSure, it is a limitation, but it removes almost all of the the overhead\\nof WARM updates. In fact, even the key comparisons of old/new tuples \\nwill return -1, 0, or 1, and from there you can know if the new key is\\nunchanged, or increasing. I assume we already do this comparison to\\ndetermine if we can do a HOT update.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 7 Aug 2016 10:49:45 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Sun, Aug 7, 2016 at 10:49:45AM -0400, Bruce Momjian wrote:\\n> OK, crazy idea time --- what if we only do WARM chain additions when all\\n> indexed values are increasing (with NULLs higher than all values)? (If\\n> a key is always-increasing, it can't match a previous value in the\\n> chain.) That avoids the problem of having to check the WARM chain,\\n> except for the previous tuple, and the problem of pruning removing\\n> changed rows. It avoids having to check the index for matching key/ctid\\n> values, and it prevents CREATE INDEX from having to index WARM chain\\n> values.\\n> \\n> Any decreasing value would cause a normal tuple be created.\\n\\nActually, when we add the first WARM tuple, we can mark the HOT/WARM\\nchain as either all-incrementing or all-decrementing. We would need a\\nbit to indicate that.\\n\\nAlso, it would be possible for keys involved in multi-key indexes to not\\nmatch the direction of the chain as long as keys earlier in the index\\nmatched, e.g. key (1,5,6) would be less than (2,1,1) since 1 < 2, even\\nthough 5 > 1. I am not sure it would be worth detecting this.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 7 Aug 2016 12:55:01 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Fri, Aug 5, 2016 at 9:57 AM, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:\\n>\\n>\\n> On Fri, Aug 5, 2016 at 8:23 AM, Claudio Freire <klaussfreire@gmail.com>\\n> wrote:\\n>>\\n>> On Thu, Aug 4, 2016 at 11:15 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n>>\\n>> >\\n>> > OK, that's a lot of text, and I am confused. Please tell me the\\n>> > advantage of having an index point to a string of HOT chains, rather\\n>> > than a single one? Is the advantage that the index points into the\\n>> > middle of the HOT chain rather than at the beginning? I can see some\\n>> > value to that, but having more ctid HOT headers that can't be removed\\n>> > except by VACUUM seems bad, plus the need for index rechecks as you\\n>> > cross to the next HOT chain seems bad.\\n>> >\\n>> > The value of WARM is to avoid index bloat --- right now we traverse the\\n>> > HOT chain on a single page just fine with no complaints about speed so I\\n>> > don't see a value to optimizing that traversal, and I think the key\\n>> > rechecks and ctid bloat will make it all much slower.\\n>> >\\n>> > It also seems much more complicated.\\n>>\\n>> The point is avoiding duplicate rows in the output of index scans.\\n>>\\n>> I don't think you can avoid it simply by applying index condition\\n>> rechecks as the original proposal implies, in this case:\\n>>\\n>> CREATE TABLE t (id integer not null primary key, someid integer, dat\\n>> integer);\\n>> CREATE INDEX i1 ON t (someid);\\n>>\\n>> INSERT INTO t (id, someid, dat) VALUES (1, 2, 100);\\n>> UPDATE t SET dat = dat + 1 where id = 1;\\n>> UPDATE t SET dat = dat + 1, id = 2 where id = 1;\\n>> UPDATE t SET dat = dat + 1, id = 3, someid = 3 where id = 2;\\n>> UPDATE t SET dat = dat + 1, id = 1, someid = 2 where id = 3;\\n>> SELECT * FROM t WHERE someid = 2;\\n>>\\n>> That, I believe, will cause the problematic chains where the condition\\n>> recheck passes both times the last visible tuple is visited during the\\n>> scan. It will return more than one tuple when in reality there is only\\n>> one.\\n>\\n>\\n> Hmm. That seems like a real problem. The only way to address that is to\\n> ensure that for a given WARM chain and given index key, there must exists\\n> only a single index entry. There can and will be multiple entries if the\\n> index key changes, but if the index key changes to the original value (or\\n> any other value already in the WARM chain) again, we must not add another\\n> index entry. Now that does not seem like a very common scenario and skipping\\n> a duplicate index entry does have its own benefit, so may be its not a\\n> terrible idea to try that. You're right, it may be expensive to search for\\n> an existing matching index key for the same root line pointer. But if we\\n> could somehow short-circuit the more common case, it might still be worth\\n> trying.\\n>\\n\\nI think here expensive part would be recheck for the cases where the\\nindex value is changed to a different value (value which doesn't exist\\nin WARM chain). You anyway have to add the new entry (key,TID) in\\nindex, but each time traversing the WARM chain would be an additional\\neffort. For cases, where there are just two index entries and one\\nthem is being updated, it might regress as compare to what we do now.\\n\\n\\n-- \\nWith Regards,\\nAmit Kapila.\\nEnterpriseDB: http://www.enterprisedb.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, 8 Aug 2016 18:34:46 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 8, 2016 at 06:34:46PM +0530, Amit Kapila wrote:\\n> I think here expensive part would be recheck for the cases where the\\n> index value is changed to a different value (value which doesn't exist\\n> in WARM chain). You anyway have to add the new entry (key,TID) in\\n> index, but each time traversing the WARM chain would be an additional\\n> effort. For cases, where there are just two index entries and one\\n> them is being updated, it might regress as compare to what we do now.\\n\\nYes, I think the all-increment or all-decrement WARM chain is going to\\nbe the right approach.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 8 Aug 2016 12:26:28 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Sun, Aug 7, 2016 at 12:55:01PM -0400, Bruce Momjian wrote:\\n> On Sun, Aug 7, 2016 at 10:49:45AM -0400, Bruce Momjian wrote:\\n> > OK, crazy idea time --- what if we only do WARM chain additions when all\\n> > indexed values are increasing (with NULLs higher than all values)? (If\\n> > a key is always-increasing, it can't match a previous value in the\\n> > chain.) That avoids the problem of having to check the WARM chain,\\n> > except for the previous tuple, and the problem of pruning removing\\n> > changed rows. It avoids having to check the index for matching key/ctid\\n> > values, and it prevents CREATE INDEX from having to index WARM chain\\n> > values.\\n> > \\n> > Any decreasing value would cause a normal tuple be created.\\n> \\n> Actually, when we add the first WARM tuple, we can mark the HOT/WARM\\n> chain as either all-incrementing or all-decrementing. We would need a\\n> bit to indicate that.\\n\\nFYI, is see at least two available tuple header bits here, 0x0800 and\\n0x1000:\\n\\n\\t/*\\n\\t * information stored in t_infomask2:\\n\\t */\\n\\t#define HEAP_NATTS_MASK 0x07FF /* 11 bits for number of attributes */\\n\\t/* bits 0x1800 are available */\\n\\t#define HEAP_KEYS_UPDATED 0x2000 /* tuple was updated and key cols\\n\\t * modified, or tuple deleted */\\n\\t#define HEAP_HOT_UPDATED 0x4000 /* tuple was HOT-updated */\\n\\t#define HEAP_ONLY_TUPLE 0x8000 /* this is heap-only tuple */\\n\\t\\n\\t#define HEAP2_XACT_MASK 0xE000 /* visibility-related bits */\\n\\nMy guess is we would need one bit to mark a WARM chain, and perhaps\\nreuse obsolete pre-9.0 HEAP_MOVED_OFF to indicate increment-only or\\ndecrement-only. These flags have to be passed to all forward tuples in\\nthe chain so an addition to the chain knows quickly if it is WARM chain,\\nand which direction.\\n\\nWe can't use the bits LP_REDIRECT lp_len because we need to create WARM\\nchains before pruning, and I don't think walking the pre-pruned chain is\\nworth it. (As I understand HOT, LP_REDIRECT is only created during\\npruning.)\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 8 Aug 2016 13:38:10 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 8, 2016 at 11:08 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n\\n> On Sun, Aug 7, 2016 at 12:55:01PM -0400, Bruce Momjian wrote:\\n> > On Sun, Aug 7, 2016 at 10:49:45AM -0400, Bruce Momjian wrote:\\n> > > OK, crazy idea time --- what if we only do WARM chain additions when\\n> all\\n> > > indexed values are increasing (with NULLs higher than all values)? (If\\n> > > a key is always-increasing, it can't match a previous value in the\\n> > > chain.) That avoids the problem of having to check the WARM chain,\\n> > > except for the previous tuple, and the problem of pruning removing\\n> > > changed rows. It avoids having to check the index for matching\\n> key/ctid\\n> > > values, and it prevents CREATE INDEX from having to index WARM chain\\n> > > values.\\n> > >\\n> > > Any decreasing value would cause a normal tuple be created.\\n> >\\n> > Actually, when we add the first WARM tuple, we can mark the HOT/WARM\\n> > chain as either all-incrementing or all-decrementing. We would need a\\n> > bit to indicate that.\\n>\\n> FYI, is see at least two available tuple header bits here, 0x0800 and\\n> 0x1000:\\n>\\n> /*\\n> * information stored in t_infomask2:\\n> */\\n> #define HEAP_NATTS_MASK 0x07FF /* 11 bits for number of\\n> attributes */\\n> /* bits 0x1800 are available */\\n> #define HEAP_KEYS_UPDATED 0x2000 /* tuple was updated and\\n> key cols\\n> * modified, or tuple\\n> deleted */\\n> #define HEAP_HOT_UPDATED 0x4000 /* tuple was HOT-updated */\\n> #define HEAP_ONLY_TUPLE 0x8000 /* this is heap-only tuple\\n> */\\n>\\n> #define HEAP2_XACT_MASK 0xE000 /* visibility-related bits\\n> */\\n>\\n\\nWhat I am currently trying to do is to reuse at least the BlockNumber field\\nin t_ctid. For HOT/WARM chains, that field is really unused (except the\\nlast tuple when regular update needs to store block number of the new\\nblock). My idea is to use one free bit in t_infomask2 to tell us that\\nt_ctid is really not a CTID, but contains new information (for pg_upgrade's\\nsake). For example, one bit in bi_hi can tell us that this is the last\\ntuple in the chain (information today conveyed by t_ctid pointing to self).\\nAnother bit can tell us that this tuple was WARM updated. We will still\\nhave plenty of bits to store additional information about WARM chains.\\n\\n\\n> My guess is we would need one bit to mark a WARM chain, and perhaps\\n> reuse obsolete pre-9.0 HEAP_MOVED_OFF to indicate increment-only or\\n> decrement-only.\\n\\n\\nI am not convinced that the checking for increment/decrement adds a lot of\\nvalue. Sure, we might be able to address some typical work load, but is\\nthat really a common use case? Instead, what I am looking at storing a\\nbitmap which shows us which table columns have changed so far in the WARM\\nchain. We only have limited bits, so we can track only limited columns.\\nThis will help the cases where different columns are updated, but not so\\nmuch if the same column is updated repeatedly.\\n\\nWhat will help, and something I haven't yet applied any thoughts, is when\\nwe can turn WARM chains back to HOT by removing stale index entries.\\n\\nSome heuristics and limits on amount of work done to detect duplicate index\\nentries will help too.\\n\\n\\n>\\n> We can't use the bits LP_REDIRECT lp_len because we need to create WARM\\n> chains before pruning, and I don't think walking the pre-pruned chain is\\n> worth it. (As I understand HOT, LP_REDIRECT is only created during\\n> pruning.)\\n>\\n>\\nThat's correct. But lp_len provides us some place to stash information from\\nheap tuples when they are pruned.\\n\\nThanks,\\nPavan\\n\\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Mon, Aug 8, 2016 at 11:08 PM, Bruce Momjian <bruce@momjian.us> wrote:On Sun, Aug 7, 2016 at 12:55:01PM -0400, Bruce Momjian wrote:\\n> On Sun, Aug 7, 2016 at 10:49:45AM -0400, Bruce Momjian wrote:\\n> > OK, crazy idea time --- what if we only do WARM chain additions when all\\n> > indexed values are increasing (with NULLs higher than all values)? (If\\n> > a key is always-increasing, it can't match a previous value in the\\n> > chain.) That avoids the problem of having to check the WARM chain,\\n> > except for the previous tuple, and the problem of pruning removing\\n> > changed rows. It avoids having to check the index for matching key/ctid\\n> > values, and it prevents CREATE INDEX from having to index WARM chain\\n> > values.\\n> >\\n> > Any decreasing value would cause a normal tuple be created.\\n>\\n> Actually, when we add the first WARM tuple, we can mark the HOT/WARM\\n> chain as either all-incrementing or all-decrementing. We would need a\\n> bit to indicate that.\\n\\nFYI, is see at least two available tuple header bits here, 0x0800 and\\n0x1000:\\n\\n /*\\n * information stored in t_infomask2:\\n */\\n #define HEAP_NATTS_MASK 0x07FF /* 11 bits for number of attributes */\\n /* bits 0x1800 are available */\\n #define HEAP_KEYS_UPDATED 0x2000 /* tuple was updated and key cols\\n * modified, or tuple deleted */\\n #define HEAP_HOT_UPDATED 0x4000 /* tuple was HOT-updated */\\n #define HEAP_ONLY_TUPLE 0x8000 /* this is heap-only tuple */\\n\\n #define HEAP2_XACT_MASK 0xE000 /* visibility-related bits */What I am currently trying to do is to reuse at least the BlockNumber field in t_ctid. For HOT/WARM chains, that field is really unused (except the last tuple when regular update needs to store block number of the new block). My idea is to use one free bit in t_infomask2 to tell us that t_ctid is really not a CTID, but contains new information (for pg_upgrade's sake). For example, one bit in bi_hi can tell us that this is the last tuple in the chain (information today conveyed by t_ctid pointing to self). Another bit can tell us that this tuple was WARM updated. We will still have plenty of bits to store additional information about WARM chains.\\n\\nMy guess is we would need one bit to mark a WARM chain, and perhaps\\nreuse obsolete pre-9.0 HEAP_MOVED_OFF to indicate increment-only or\\ndecrement-only. I am not convinced that the checking for increment/decrement adds a lot of value. Sure, we might be able to address some typical work load, but is that really a common use case? Instead, what I am looking at storing a bitmap which shows us which table columns have changed so far in the WARM chain. We only have limited bits, so we can track only limited columns. This will help the cases where different columns are updated, but not so much if the same column is updated repeatedly.What will help, and something I haven't yet applied any thoughts, is when we can turn WARM chains back to HOT by removing stale index entries.Some heuristics and limits on amount of work done to detect duplicate index entries will help too. \\nWe can't use the bits LP_REDIRECT lp_len because we need to create WARM\\nchains before pruning, and I don't think walking the pre-pruned chain is\\nworth it. (As I understand HOT, LP_REDIRECT is only created during\\npruning.)\\nThat's correct. But lp_len provides us some place to stash information from heap tuples when they are pruned. Thanks,Pavan Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Mon, 8 Aug 2016 23:22:49 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 8, 2016 at 2:52 PM, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:\\n>>\\n>> My guess is we would need one bit to mark a WARM chain, and perhaps\\n>> reuse obsolete pre-9.0 HEAP_MOVED_OFF to indicate increment-only or\\n>> decrement-only.\\n>\\n>\\n> I am not convinced that the checking for increment/decrement adds a lot of\\n> value. Sure, we might be able to address some typical work load, but is that\\n> really a common use case? Instead, what I am looking at storing a bitmap\\n> which shows us which table columns have changed so far in the WARM chain. We\\n> only have limited bits, so we can track only limited columns. This will help\\n> the cases where different columns are updated, but not so much if the same\\n> column is updated repeatedly.\\n>\\n> What will help, and something I haven't yet applied any thoughts, is when we\\n> can turn WARM chains back to HOT by removing stale index entries.\\n>\\n> Some heuristics and limits on amount of work done to detect duplicate index\\n> entries will help too.\\n\\nI think I prefer a more thorough approach.\\n\\nIncrement/decrement may get very complicated with custom opclasses,\\nfor instance. A column-change bitmap won't know how to handle\\nfuncional indexes, etc.\\n\\nWhat I intend to try, is modify btree to allow efficient search of a\\nkey-ctid pair, by adding the ctid to the sort order. Only inner pages\\nneed to be changed, to include the ctid in the pointers, leaf pages\\nalready have the ctid there, so they don't need any kind of change. A\\nbit in the metapage could indicate whether it's a new format or an old\\none, and yes, only new indices will be able to use WARM.\\n\\nBut with efficient key-ctid searches, you handle all cases, and not\\njust a few common ones.\\n\\nA lot of the work for the key-ctid search can be shared with the\\nupdate itself, so it's probably not such a big performance impact.\\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, 8 Aug 2016 15:36:12 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 8, 2016 at 11:22:49PM +0530, Pavan Deolasee wrote:\\n> What I am currently trying to do is to reuse at least the BlockNumber field in\\n> t_ctid. For HOT/WARM chains, that field is really unused (except the last tuple\\n> when regular update needs to store block number of the new block). My idea is\\n> to use one free bit in t_infomask2 to tell us that t_ctid is really not a CTID,\\n> but contains new information (for pg_upgrade's sake). For example, one bit in\\n> bi_hi can tell us that this is the last tuple in the chain (information today\\n> conveyed by t_ctid pointing to self). Another bit can tell us that this tuple\\n> was WARM updated. We will still have plenty of bits to store additional\\n> information about WARM chains.\\n\\nYes, that works too, though it probably only makes sense if we can make\\nuse of more than one bit in bi_hi.\\n\\n> My guess is we would need one bit to mark a WARM chain, and perhaps\\n> reuse obsolete pre-9.0 HEAP_MOVED_OFF to indicate increment-only or\\n> decrement-only.�\\n> \\n> \\n> I am not convinced that the checking for increment/decrement adds a lot of\\n> value. Sure, we might be able to address some typical work load, but is that\\n> really a common use case? Instead, what I am looking at storing a bitmap which\\n\\nI have no idea, but it guarantees that the first WARM update works\\nbecause there is no direction set. Then, if the direction changes, you\\ncreate a new chain and hope the changes stay in that direction for a\\nwhile.\\n\\n> shows us which table columns have changed so far in the WARM chain. We only\\n> have limited bits, so we can track only limited columns. This will help the\\n> cases where different columns are updated, but not so much if the same column\\n> is updated repeatedly.\\n\\nWell, I don't think in 15 bits we have enough space to store many column\\nnumbers, let alone column numbers and _values_. You would need four\\nbits (1-16) to exceed what you can store in a simple bitmap of the first\\n15 columns. If you want to extend that range, you can use 8 bits (2^8)\\nto record one of the first 256 column numbers. You could do 7 bits (2^7\\n= 128) and use another bit per column to record the increment/decrement\\ndirection, meaning that repeated changes to the same column in the same\\ndirection would be allowed in the same WARM chain. I think it is more\\nlikely that the same column is going to be changed in the same WARM\\nchain, than changes in different columns.\\n\\nFrankly, with only 16 bits, I can't see how recording specific columns\\nreally buys us much because we have to limit the column number storage.\\nPlus, if a column changes twice, you need to create a new WARM chain\\nunless you record the increment/decrement direction.\\n\\nWhat we could do is to record the first two changed columns in the\\n16-bit field, with direction, then record a bit for direction of all\\ncolumns not in the first two that change. That allows you to record\\nthree sets of directions in the same HOT chain. It does not allow you\\nto change the direction of any column previously recorded in the WARM\\nchain.\\n\\nYou could say you are going to scan the WARM chain for changes, but that\\nlimits pruning. You could try storing just the changes for pruned rows,\\nbut then you are going to have a lot of overhead scanning the WARM chain\\nlooking for changes.\\n\\nIt would be interesting to store the change _direction_ for the first 15\\ncolumns in the bitmap, and then use the 16th bit for the rest of the\\ncolumns, but I can't figure out how to record which bits are set with a\\ndirection and which are the default/unused. You really need two bits\\nper column, so that only records the first seven or eight columns.\\n\\n> What will help, and something I haven't yet applied any thoughts, is when we\\n> can turn WARM chains back to HOT by removing stale index entries.\\n\\nI can't see how we can ever do that because we have multiple indexes\\npointing to the chain, and keys that might be duplicated if we switched\\nto HOT. Seems only VACUUM can fix that.\\n\\n> Some heuristics and limits on amount of work done to detect duplicate index\\n> entries will help too.\\n\\nYeah, I have kind of given up on that.\\n\\n> > We can't use the bits LP_REDIRECT lp_len because we need to create WARM\\n> > chains before pruning, and I don't think walking the pre-pruned chain is\\n> > worth it. (As I understand HOT, LP_REDIRECT is only created during\\n> > pruning.)\\n> \\n> That's correct. But lp_len provides us some place to stash information from\\n> heap tuples when they are pruned.\\n\\nRight. However, I see storing information at prune time as only useful\\nif you are willing to scan the chain, and frankly, I have given up on\\nchain scanning (with column comparisons) as being too expensive for \\nits limited value. What we could do is to use the LP_REDIRECT lp_len to\\nstore information of two more changed column numbers, with directions. \\nHowever, once you store one bit that records the direction of all other\\ncolumns, you can't go back and record the changes, unless you do a chain\\nscan at prune time.\\n\\nYou have to wonder how much complexity is reasonable for this.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 8 Aug 2016 16:19:08 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 8, 2016 at 03:36:12PM -0300, Claudio Freire wrote:\\n> I think I prefer a more thorough approach.\\n> \\n> Increment/decrement may get very complicated with custom opclasses,\\n> for instance. A column-change bitmap won't know how to handle\\n> funcional indexes, etc.\\n\\nHot does HOT handle them? If it does, it has to look at all the columns\\npasses to the expression index, so it seems to be the same amount of\\nwork.\\n\\n> What I intend to try, is modify btree to allow efficient search of a\\n> key-ctid pair, by adding the ctid to the sort order. Only inner pages\\n> need to be changed, to include the ctid in the pointers, leaf pages\\n> already have the ctid there, so they don't need any kind of change. A\\n> bit in the metapage could indicate whether it's a new format or an old\\n> one, and yes, only new indices will be able to use WARM.\\n> \\n> But with efficient key-ctid searches, you handle all cases, and not\\n> just a few common ones.\\n\\nTrue. I am worried about page spills caused by having to insert a rows\\ninto an existing page and and index entry having to be pushed to an\\nadjacent page to maintain ctid index order.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 8 Aug 2016 16:24:30 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 8, 2016 at 5:24 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n> On Mon, Aug 8, 2016 at 03:36:12PM -0300, Claudio Freire wrote:\\n>> I think I prefer a more thorough approach.\\n>>\\n>> Increment/decrement may get very complicated with custom opclasses,\\n>> for instance. A column-change bitmap won't know how to handle\\n>> funcional indexes, etc.\\n>\\n> Hot does HOT handle them? If it does, it has to look at all the columns\\n> passes to the expression index, so it seems to be the same amount of\\n> work.\\n\\nThe way HOT handles it IIRC induces false positives (as in: HOT is\\nforbidden when it might be ok) because it may flag as changed\\nexpressions that don't change. Think date_trunc('day', timestamp), if\\nthe timestamp changes within a day, there's no change in reality, but\\nthe column changed so HOT is forbidden. But the logic won't create\\nfalse negatives (allow HOT when it's not allowed).\\n\\nBut for WARM that might be the case, because the guarantee that you\\nneed is that no key already present in the WARM chain will be\\nre-added. An index over (a - b) could have both a and b in increasing\\norder yet repeat keys and violate the WARM chain invariant.\\n\\n>> What I intend to try, is modify btree to allow efficient search of a\\n>> key-ctid pair, by adding the ctid to the sort order. Only inner pages\\n>> need to be changed, to include the ctid in the pointers, leaf pages\\n>> already have the ctid there, so they don't need any kind of change. A\\n>> bit in the metapage could indicate whether it's a new format or an old\\n>> one, and yes, only new indices will be able to use WARM.\\n>>\\n>> But with efficient key-ctid searches, you handle all cases, and not\\n>> just a few common ones.\\n>\\n> True. I am worried about page spills caused by having to insert a rows\\n> into an existing page and and index entry having to be pushed to an\\n> adjacent page to maintain ctid index order.\\n\\nI don't think it would be a concern, as inserting a serial column shouldn't.\\n\\nMaybe some pages will split that wouldn't have, but the split will add\\nroom to the new leaf pages and some splits that would have split\\nbefore won't happen afterwards.\\n\\nThink of it as equivalent to adding the oid to the index - it's some\\nimmutable attribute of the row being inserted, the fact that it is a\\ntid shouldn't make a difference to the performance of the btree, aside\\nfrom the extra comparisons perhaps.\\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, 8 Aug 2016 17:36:13 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On 8/8/16 3:19 PM, Bruce Momjian wrote:\\n>> What will help, and something I haven't yet applied any thoughts, is when we\\n>> > can turn WARM chains back to HOT by removing stale index entries.\\n> I can't see how we can ever do that because we have multiple indexes\\n> pointing to the chain, and keys that might be duplicated if we switched\\n> to HOT. Seems only VACUUM can fix that.\\n\\nAre these changes still predicated on being able to re-find all index \\nentries by key value? If so, that makes incremental vacuums practical, \\nperhaps eliminating a lot of these issues.\\n\\n>>> > > We can't use the bits LP_REDIRECT lp_len because we need to create WARM\\n>>> > > chains before pruning, and I don't think walking the pre-pruned chain is\\n>>> > > worth it. (As I understand HOT, LP_REDIRECT is only created during\\n>>> > > pruning.)\\n>> >\\n>> > That's correct. But lp_len provides us some place to stash information from\\n>> > heap tuples when they are pruned.\\n> Right. However, I see storing information at prune time as only useful\\n> if you are willing to scan the chain, and frankly, I have given up on\\n> chain scanning (with column comparisons) as being too expensive for\\n> its limited value.\\n\\nWhat if some of this work happened asynchronously? I'm thinking \\nsomething that runs through shared_buffers in front of bgwriter.\\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\\n855-TREBLE2 (855-873-2532) mobile: 512-569-9461\\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, 9 Aug 2016 18:19:57 -0500\",\n \"msg_from\": \"Jim Nasby <Jim.Nasby@BlueTreble.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Tue, Aug 9, 2016 at 8:19 PM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:\\n> On 8/8/16 3:19 PM, Bruce Momjian wrote:\\n>>>\\n>>> What will help, and something I haven't yet applied any thoughts, is when\\n>>> we\\n>>> > can turn WARM chains back to HOT by removing stale index entries.\\n>>\\n>> I can't see how we can ever do that because we have multiple indexes\\n>> pointing to the chain, and keys that might be duplicated if we switched\\n>> to HOT. Seems only VACUUM can fix that.\\n>\\n>\\n> Are these changes still predicated on being able to re-find all index\\n> entries by key value? If so, that makes incremental vacuums practical,\\n> perhaps eliminating a lot of these issues.\\n>\\n>>>> > > We can't use the bits LP_REDIRECT lp_len because we need to create\\n>>>> > > WARM\\n>>>> > > chains before pruning, and I don't think walking the pre-pruned\\n>>>> > > chain is\\n>>>> > > worth it. (As I understand HOT, LP_REDIRECT is only created during\\n>>>> > > pruning.)\\n>>>\\n>>> >\\n>>> > That's correct. But lp_len provides us some place to stash information\\n>>> > from\\n>>> > heap tuples when they are pruned.\\n>>\\n>> Right. However, I see storing information at prune time as only useful\\n>> if you are willing to scan the chain, and frankly, I have given up on\\n>> chain scanning (with column comparisons) as being too expensive for\\n>> its limited value.\\n>\\n>\\n> What if some of this work happened asynchronously? I'm thinking something\\n> that runs through shared_buffers in front of bgwriter.\\n\\nIf one can find key-ctid pairs efficiently in the index, this can be\\ndone during WARM pruning (ie: during updates, when we're already doing\\nthe index lookups anyway).\\n\\nSuppose you have the following chain:\\n\\nindex 0 1 2 3 4\\nk1 a a a a a\\nk2 a a b a a\\ni1 ^\\ni2 ^ ^\\nhot * *\\n\\nIf versions 0-2 die, pruning can free 1 (it's HOT), and leave\\nredirects in 0 and 2:\\n\\nindex 0 1 2 3 4\\nk1 a . a a a\\nk2 a . b a a\\ni1 ^\\ni2 ^ ^\\nlp r2 u r3\\nhot *\\n\\nSince we can lookup all occurrences of k1=a index=0 and k2=a index=0,\\nand in fact we probably did so already as part of the update logic, we\\ncan remove the first redirect by pointing indexes to 2:\\n\\nindex 0 1 2 3 4\\nk1 . . a a a\\nk2 . . b a a\\ni1 ^\\ni2 ^ ^\\nlp u u r3\\nhot *\\n\\nSo WARM pruning would have to happen just prior to adding a WARM tuple\\nto be able to reuse all the index lookup work to do the index pruning\\nwith the writing.\\n\\nThe indexam interface will get considerably more complex in order to\\ndo this, however. So perhaps it would be ok to do 2 independent\\nlookups instead? I'm undecided yet.\\n\\nBut one way or the other, pruning can happen early and incrementally.\\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, 9 Aug 2016 20:44:12 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Tue, Aug 9, 2016 at 8:44 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n> index 0 1 2 3 4\\n> k1 . . a a a\\n> k2 . . b a a\\n> i1 ^\\n> i2 ^ ^\\n> lp u u r3\\n> hot *\\n\\n\\nSorry, that should read:\\n\\nindex 0 1 2 3 4\\nk1 . . a a a\\nk2 . . b a a\\ni1 ^\\ni2 ^\\nlp u u r3\\nhot *\\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, 9 Aug 2016 20:46:21 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Tue, Aug 9, 2016 at 06:19:57PM -0500, Jim Nasby wrote:\\n> On 8/8/16 3:19 PM, Bruce Momjian wrote:\\n> >>What will help, and something I haven't yet applied any thoughts, is when we\\n> >>> can turn WARM chains back to HOT by removing stale index entries.\\n> >I can't see how we can ever do that because we have multiple indexes\\n> >pointing to the chain, and keys that might be duplicated if we switched\\n> >to HOT. Seems only VACUUM can fix that.\\n> \\n> Are these changes still predicated on being able to re-find all index\\n> entries by key value? If so, that makes incremental vacuums practical,\\n> perhaps eliminating a lot of these issues.\\n\\nNo, the increment/decrement doesn't require btree lookups.\\n\\n> >>>> > We can't use the bits LP_REDIRECT lp_len because we need to create WARM\\n> >>>> > chains before pruning, and I don't think walking the pre-pruned chain is\\n> >>>> > worth it. (As I understand HOT, LP_REDIRECT is only created during\\n> >>>> > pruning.)\\n> >>>\\n> >>> That's correct. But lp_len provides us some place to stash information from\\n> >>> heap tuples when they are pruned.\\n> >Right. However, I see storing information at prune time as only useful\\n> >if you are willing to scan the chain, and frankly, I have given up on\\n> >chain scanning (with column comparisons) as being too expensive for\\n> >its limited value.\\n> \\n> What if some of this work happened asynchronously? I'm thinking something\\n> that runs through shared_buffers in front of bgwriter.\\n\\nWell, we prune when we need the space --- that is the big value of page\\npruning, that it is fast can be done when you need it. VACUUM is all\\nabout background cleanup.\\n\\n-- \\n Bruce Momjian <bruce@momjian.us> http://momjian.us\\n EnterpriseDB http://enterprisedb.com\\n\\n+ As you are, so once was I. As I am, so you will be. +\\n+ Ancient Roman grave inscription +\\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, 9 Aug 2016 22:07:41 -0400\",\n \"msg_from\": \"Bruce Momjian <bruce@momjian.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On 8/9/16 6:46 PM, Claudio Freire wrote:\\n> On Tue, Aug 9, 2016 at 8:44 PM, Claudio Freire <klaussfreire@gmail.com> wrote:\\n>> index 0 1 2 3 4\\n>> k1 . . a a a\\n>> k2 . . b a a\\n>> i1 ^\\n>> i2 ^ ^\\n>> lp u u r3\\n>> hot *\\n>\\n>\\n> Sorry, that should read:\\n>\\n> index 0 1 2 3 4\\n> k1 . . a a a\\n> k2 . . b a a\\n> i1 ^\\n> i2 ^\\n> lp u u r3\\n> hot *\\n>\\n\\nFWIW, your ascii-art is unfortunately getting bungled somewhere I think :/.\\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\\n855-TREBLE2 (855-873-2532) mobile: 512-569-9461\\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, 9 Aug 2016 21:29:22 -0500\",\n \"msg_from\": \"Jim Nasby <Jim.Nasby@BlueTreble.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On 8/9/16 6:44 PM, Claudio Freire wrote:\\n> Since we can lookup all occurrences of k1=a index=0 and k2=a index=0,\\n> and in fact we probably did so already as part of the update logic\\n\\nThat's a change from what currently happens, right?\\n\\nThe reason I think that's important is that dropping the assumption that \\nwe can't safely re-find index entries from the heap opens up other \\noptimizations, ones that should be significantly simpler to implement. \\nThe most obvious example being getting rid of full index scans in \\nvacuum. While that won't help with write amplification, it would reduce \\nthe cost of vacuum enormously. Orders of magnitude wouldn't surprise me \\nin the least.\\n\\nIf that's indeed a prerequisite to WARM it would be great to get that \\ngroundwork laid early so others could work on other optimizations it \\nwould enable.\\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\\n855-TREBLE2 (855-873-2532) mobile: 512-569-9461\\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, 9 Aug 2016 21:39:58 -0500\",\n \"msg_from\": \"Jim Nasby <Jim.Nasby@BlueTreble.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Tue, Aug 9, 2016 at 12:06 AM, Claudio Freire <klaussfreire@gmail.com>\\nwrote:\\n\\n> On Mon, Aug 8, 2016 at 2:52 PM, Pavan Deolasee <pavan.deolasee@gmail.com>\\n> wrote:\\n>\\n> > Some heuristics and limits on amount of work done to detect duplicate\\n> index\\n> > entries will help too.\\n>\\n> I think I prefer a more thorough approach.\\n>\\n> Increment/decrement may get very complicated with custom opclasses,\\n> for instance. A column-change bitmap won't know how to handle\\n> funcional indexes, etc.\\n>\\n> What I intend to try, is modify btree to allow efficient search of a\\n> key-ctid pair, by adding the ctid to the sort order.\\n\\n\\nYes, that's a good medium term plan. And this is kind of independent from\\nthe core idea. So I'll go ahead and write a patch that implements the core\\nidea and some basic optimizations. We can then try different approaches\\nsuch as tracking changed columns, tracking increment/decrement and teaching\\nbtree to skip duplicate (key, CTID) entries.\\n\\nThanks,\\nPavan\\n\\n-- \\n Pavan Deolasee http://www.2ndQuadrant.com/\\n PostgreSQL Development, 24x7 Support, Training & Services\\n\\nOn Tue, Aug 9, 2016 at 12:06 AM, Claudio Freire <klaussfreire@gmail.com> wrote:On Mon, Aug 8, 2016 at 2:52 PM, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:\\n> Some heuristics and limits on amount of work done to detect duplicate index\\n> entries will help too.\\n\\nI think I prefer a more thorough approach.\\n\\nIncrement/decrement may get very complicated with custom opclasses,\\nfor instance. A column-change bitmap won't know how to handle\\nfuncional indexes, etc.\\n\\nWhat I intend to try, is modify btree to allow efficient search of a\\nkey-ctid pair, by adding the ctid to the sort order.Yes, that's a good medium term plan. And this is kind of independent from the core idea. So I'll go ahead and write a patch that implements the core idea and some basic optimizations. We can then try different approaches such as tracking changed columns, tracking increment/decrement and teaching btree to skip duplicate (key, CTID) entries. Thanks,Pavan-- Pavan Deolasee http://www.2ndQuadrant.com/ PostgreSQL Development, 24x7 Support, Training & Services\",\n \"msg_date\": \"Wed, 10 Aug 2016 08:15:26 +0530\",\n \"msg_from\": \"Pavan Deolasee <pavan.deolasee@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Tue, Aug 9, 2016 at 11:39 PM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:\\n> On 8/9/16 6:44 PM, Claudio Freire wrote:\\n>>\\n>> Since we can lookup all occurrences of k1=a index=0 and k2=a index=0,\\n>> and in fact we probably did so already as part of the update logic\\n>\\n>\\n> That's a change from what currently happens, right?\\n>\\n> The reason I think that's important is that dropping the assumption that we\\n> can't safely re-find index entries from the heap opens up other\\n> optimizations, ones that should be significantly simpler to implement. The\\n> most obvious example being getting rid of full index scans in vacuum. While\\n> that won't help with write amplification, it would reduce the cost of vacuum\\n> enormously. Orders of magnitude wouldn't surprise me in the least.\\n>\\n> If that's indeed a prerequisite to WARM it would be great to get that\\n> groundwork laid early so others could work on other optimizations it would\\n> enable.\\n\\nI can do that. I've been prospecting the code to see what changes it\\nwould entail already.\\n\\nBut it's still specific to btree, I'm not sure the same optimizations\\ncan be applied to GIN (maybe, if the posting list is sorted) or GIST\\n(probably, since it's like a btree, but I don't know the code well\\nenough).\\n\\nCertainly hash indexes won't support it.\\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, 10 Aug 2016 14:48:15 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On 10 August 2016 at 03:45, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:\\n>\\n>\\n> On Tue, Aug 9, 2016 at 12:06 AM, Claudio Freire <klaussfreire@gmail.com>\\n> wrote:\\n>>\\n>> On Mon, Aug 8, 2016 at 2:52 PM, Pavan Deolasee <pavan.deolasee@gmail.com>\\n>> wrote:\\n>>\\n>> > Some heuristics and limits on amount of work done to detect duplicate\\n>> > index\\n>> > entries will help too.\\n>>\\n>> I think I prefer a more thorough approach.\\n>>\\n>> Increment/decrement may get very complicated with custom opclasses,\\n>> for instance. A column-change bitmap won't know how to handle\\n>> funcional indexes, etc.\\n>>\\n>> What I intend to try, is modify btree to allow efficient search of a\\n>> key-ctid pair, by adding the ctid to the sort order.\\n>\\n>\\n> Yes, that's a good medium term plan. And this is kind of independent from\\n> the core idea.\\n\\n+1 That seems like a good idea. It would allow us to produce a bitmap\\nscan in blocksorted order.\\n\\n> So I'll go ahead and write a patch that implements the core\\n> idea and some basic optimizations.\\n\\n+1\\n\\n> We can then try different approaches such\\n> as tracking changed columns, tracking increment/decrement and teaching btree\\n> to skip duplicate (key, CTID) entries.\\n\\n-- \\nSimon Riggs 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, 10 Aug 2016 20:37:07 +0100\",\n \"msg_from\": \"Simon Riggs <simon@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Wed, Aug 10, 2016 at 4:37 PM, Simon Riggs <simon@2ndquadrant.com> wrote:\\n> On 10 August 2016 at 03:45, Pavan Deolasee <pavan.deolasee@gmail.com> wrote:\\n>>\\n>>\\n>> On Tue, Aug 9, 2016 at 12:06 AM, Claudio Freire <klaussfreire@gmail.com>\\n>> wrote:\\n>>>\\n>>> On Mon, Aug 8, 2016 at 2:52 PM, Pavan Deolasee <pavan.deolasee@gmail.com>\\n>>> wrote:\\n>>>\\n>>> > Some heuristics and limits on amount of work done to detect duplicate\\n>>> > index\\n>>> > entries will help too.\\n>>>\\n>>> I think I prefer a more thorough approach.\\n>>>\\n>>> Increment/decrement may get very complicated with custom opclasses,\\n>>> for instance. A column-change bitmap won't know how to handle\\n>>> funcional indexes, etc.\\n>>>\\n>>> What I intend to try, is modify btree to allow efficient search of a\\n>>> key-ctid pair, by adding the ctid to the sort order.\\n>>\\n>>\\n>> Yes, that's a good medium term plan. And this is kind of independent from\\n>> the core idea.\\n>\\n> +1 That seems like a good idea. It would allow us to produce a bitmap\\n> scan in blocksorted order.\\n\\nWell, not really. Only equal-key runs will be block-sorted, since the\\nsort order would be (key, block, offset).\\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, 10 Aug 2016 16:41:04 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 8, 2016 at 9:56 PM, Bruce Momjian <bruce@momjian.us> wrote:\\n> On Mon, Aug 8, 2016 at 06:34:46PM +0530, Amit Kapila wrote:\\n>> I think here expensive part would be recheck for the cases where the\\n>> index value is changed to a different value (value which doesn't exist\\n>> in WARM chain). You anyway have to add the new entry (key,TID) in\\n>> index, but each time traversing the WARM chain would be an additional\\n>> effort. For cases, where there are just two index entries and one\\n>> them is being updated, it might regress as compare to what we do now.\\n>\\n> Yes, I think the all-increment or all-decrement WARM chain is going to\\n> be the right approach.\\n>\\n\\nProbably, it will mitigate the cost in some cases, still there will be\\na cost in comparisons especially when index is on char/varchar\\ncolumns. Also, I think it will reduce the chance of performing WARM\\nupdate in certain cases considering we can create a WARM tuple only\\nwhen it follows the order. OTOH, if we store pointers in index to\\nintermediate tuples, we won't face such issues. Yes, there will be\\nsome delay in cleanup of intermediate line pointers, however I think\\nwe can clear those once we mark the corresponding index tuples as dead\\nin the next scan on corresponding index.\\n\\n-- \\nWith Regards,\\nAmit Kapila.\\nEnterpriseDB: http://www.enterprisedb.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\": \"Thu, 11 Aug 2016 11:16:18 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On 8/10/16 12:48 PM, Claudio Freire wrote:\\n> On Tue, Aug 9, 2016 at 11:39 PM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:\\n>> On 8/9/16 6:44 PM, Claudio Freire wrote:\\n>>>\\n>>> Since we can lookup all occurrences of k1=a index=0 and k2=a index=0,\\n>>> and in fact we probably did so already as part of the update logic\\n>>\\n>>\\n>> That's a change from what currently happens, right?\\n>>\\n>> The reason I think that's important is that dropping the assumption that we\\n>> can't safely re-find index entries from the heap opens up other\\n>> optimizations, ones that should be significantly simpler to implement. The\\n>> most obvious example being getting rid of full index scans in vacuum. While\\n>> that won't help with write amplification, it would reduce the cost of vacuum\\n>> enormously. Orders of magnitude wouldn't surprise me in the least.\\n>>\\n>> If that's indeed a prerequisite to WARM it would be great to get that\\n>> groundwork laid early so others could work on other optimizations it would\\n>> enable.\\n>\\n> I can do that. I've been prospecting the code to see what changes it\\n> would entail already.\\n>\\n> But it's still specific to btree, I'm not sure the same optimizations\\n> can be applied to GIN (maybe, if the posting list is sorted) or GIST\\n> (probably, since it's like a btree, but I don't know the code well\\n> enough).\\n>\\n> Certainly hash indexes won't support it.\\n\\nWhy not? If this is all predicated on re-finding index keys based on \\nheap data then this is just another index lookup, no?\\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\\n855-TREBLE2 (855-873-2532) mobile: 512-569-9461\\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, 11 Aug 2016 09:07:27 -0500\",\n \"msg_from\": \"Jim Nasby <Jim.Nasby@BlueTreble.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 11, 2016 at 11:07 AM, Jim Nasby <Jim.Nasby@bluetreble.com> wrote:\\n> On 8/10/16 12:48 PM, Claudio Freire wrote:\\n>>\\n>> On Tue, Aug 9, 2016 at 11:39 PM, Jim Nasby <Jim.Nasby@bluetreble.com>\\n>> wrote:\\n>>>\\n>>> On 8/9/16 6:44 PM, Claudio Freire wrote:\\n>>>>\\n>>>>\\n>>>> Since we can lookup all occurrences of k1=a index=0 and k2=a index=0,\\n>>>> and in fact we probably did so already as part of the update logic\\n>>>\\n>>>\\n>>>\\n>>> That's a change from what currently happens, right?\\n>>>\\n>>> The reason I think that's important is that dropping the assumption that\\n>>> we\\n>>> can't safely re-find index entries from the heap opens up other\\n>>> optimizations, ones that should be significantly simpler to implement.\\n>>> The\\n>>> most obvious example being getting rid of full index scans in vacuum.\\n>>> While\\n>>> that won't help with write amplification, it would reduce the cost of\\n>>> vacuum\\n>>> enormously. Orders of magnitude wouldn't surprise me in the least.\\n>>>\\n>>> If that's indeed a prerequisite to WARM it would be great to get that\\n>>> groundwork laid early so others could work on other optimizations it\\n>>> would\\n>>> enable.\\n>>\\n>>\\n>> I can do that. I've been prospecting the code to see what changes it\\n>> would entail already.\\n>>\\n>> But it's still specific to btree, I'm not sure the same optimizations\\n>> can be applied to GIN (maybe, if the posting list is sorted) or GIST\\n>> (probably, since it's like a btree, but I don't know the code well\\n>> enough).\\n>>\\n>> Certainly hash indexes won't support it.\\n>\\n>\\n> Why not? If this is all predicated on re-finding index keys based on heap\\n> data then this is just another index lookup, no?\\n\\nA lookup on a hash index cannot be made to work for both key-only\\nlookups and key-ctid lookups, it's a limitation of the data structure.\\n\\nA key-only lookup can potentially return too many results that don't\\nmatch the ctid so a walk of all equal-key item pointers is out of the\\nquestion.\\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, 11 Aug 2016 13:57:09 -0300\",\n \"msg_from\": \"Claudio Freire <klaussfreire@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Heap WARM Tuples - Design Draft\"\n }\n]","isConversational":false}}},{"rowIdx":42894,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Hi all,\n\nI was looking through the buffer manager's code and have noticed that \nfunction PinBuffer has an unused 'strategy' argument. It's seems that \nafter refactoring made by Alexander Korotkov and Andres Freund \n(48354581a49c30f5757c203415aa8412d85b0f70) it became useless. The \nattached patch removes it. Probably someone more advanced could edit the \nfunction description to reflect changes?\n\nRegards,\n\n-- \nIldar Musin\ni.musin@postgrespro.ru\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","msg_date":"Thu, 4 Aug 2016 14:28:30 +0300","msg_from":"Ildar Musin <i.musin@postgrespro.ru>","msg_from_op":true,"msg_subject":"Unused argument in PinBuffer function"},{"msg_contents":"On Thu, Aug 4, 2016 at 2:28 PM, Ildar Musin <i.musin@postgrespro.ru> wrote:\n\n> I was looking through the buffer manager's code and have noticed that\n> function PinBuffer has an unused 'strategy' argument. It's seems that after\n> refactoring made by Alexander Korotkov and Andres Freund\n> (48354581a49c30f5757c203415aa8412d85b0f70) it became useless. The\n> attached patch removes it. Probably someone more advanced could edit the\n> function description to reflect changes?\n>\n\n48354581 contain unintentional change that made 'strategy' argument of\nPinBuffer unused.\nSince it was an unintentional change, it was decided to put old logic\nback. See 9cf60332.\nThus, now 'strategy' argument of PinBuffer is used.\n\n------\nAlexander Korotkov\nPostgres Professional: http://www.postgrespro.com\nThe Russian Postgres Company\n\nOn Thu, Aug 4, 2016 at 2:28 PM, Ildar Musin <i.musin@postgrespro.ru> wrote:I was looking through the buffer manager's code and have noticed that function PinBuffer has an unused 'strategy' argument. It's seems that after refactoring made by Alexander Korotkov and Andres Freund (48354581a49c30f5757c203415aa8412d85b0f70) it became useless. The attached patch removes it. Probably someone more advanced could edit the function description to reflect changes?48354581 contain unintentional change that made 'strategy' argument of PinBuffer unused.Since it was an unintentional change, it was decided to put old logic back. See 9cf60332.Thus, now 'strategy' argument of PinBuffer is used.------Alexander KorotkovPostgres Professional: http://www.postgrespro.comThe Russian Postgres Company","msg_date":"Mon, 27 Mar 2017 21:13:40 +0300","msg_from":"Alexander Korotkov <a.korotkov@postgrespro.ru>","msg_from_op":false,"msg_subject":"Re: Unused argument in PinBuffer function"}],"string":"[\n {\n \"msg_contents\": \"Hi all,\\n\\nI was looking through the buffer manager's code and have noticed that \\nfunction PinBuffer has an unused 'strategy' argument. It's seems that \\nafter refactoring made by Alexander Korotkov and Andres Freund \\n(48354581a49c30f5757c203415aa8412d85b0f70) it became useless. The \\nattached patch removes it. Probably someone more advanced could edit the \\nfunction description to reflect changes?\\n\\nRegards,\\n\\n-- \\nIldar Musin\\ni.musin@postgrespro.ru\\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\": \"Thu, 4 Aug 2016 14:28:30 +0300\",\n \"msg_from\": \"Ildar Musin <i.musin@postgrespro.ru>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Unused argument in PinBuffer function\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 2:28 PM, Ildar Musin <i.musin@postgrespro.ru> wrote:\\n\\n> I was looking through the buffer manager's code and have noticed that\\n> function PinBuffer has an unused 'strategy' argument. It's seems that after\\n> refactoring made by Alexander Korotkov and Andres Freund\\n> (48354581a49c30f5757c203415aa8412d85b0f70) it became useless. The\\n> attached patch removes it. Probably someone more advanced could edit the\\n> function description to reflect changes?\\n>\\n\\n48354581 contain unintentional change that made 'strategy' argument of\\nPinBuffer unused.\\nSince it was an unintentional change, it was decided to put old logic\\nback. See 9cf60332.\\nThus, now 'strategy' argument of PinBuffer is used.\\n\\n------\\nAlexander Korotkov\\nPostgres Professional: http://www.postgrespro.com\\nThe Russian Postgres Company\\n\\nOn Thu, Aug 4, 2016 at 2:28 PM, Ildar Musin <i.musin@postgrespro.ru> wrote:I was looking through the buffer manager's code and have noticed that function PinBuffer has an unused 'strategy' argument. It's seems that after refactoring made by Alexander Korotkov and Andres Freund (48354581a49c30f5757c203415aa8412d85b0f70) it became useless. The attached patch removes it. Probably someone more advanced could edit the function description to reflect changes?48354581 contain unintentional change that made 'strategy' argument of PinBuffer unused.Since it was an unintentional change, it was decided to put old logic back. See 9cf60332.Thus, now 'strategy' argument of PinBuffer is used.------Alexander KorotkovPostgres Professional: http://www.postgrespro.comThe Russian Postgres Company\",\n \"msg_date\": \"Mon, 27 Mar 2017 21:13:40 +0300\",\n \"msg_from\": \"Alexander Korotkov <a.korotkov@postgrespro.ru>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Unused argument in PinBuffer function\"\n }\n]","isConversational":false}}},{"rowIdx":42895,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Recently I've encountered a strange crash while calling elog(ERROR, \"...\") \nafter the WaitForBackgroundWorkerShutdown() function. It turns out that \n_returns_ inside the PG_TRY()..PG_CATCH() block are *highly* undesirable, \nsince they leave PG_exception_stack pointing to a local struct in a dead \nframe, which is an obvious UB. I've attached a patch which fixes this behavior \nin the aforementioned function, but there might be more errors like that \nelsewhere.\n\n-- \nDmitry Ivanov\nPostgres Professional: http://www.postgrespro.com\nRussian Postgres 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","msg_date":"Thu, 04 Aug 2016 14:44:08 +0300","msg_from":"Dmitry Ivanov <d.ivanov@postgrespro.ru>","msg_from_op":true,"msg_subject":"Bug in WaitForBackgroundWorkerShutdown() [REL9_5_STABLE]"},{"msg_contents":"> Recently I've encountered a strange crash while calling elog(ERROR, \"...\")\n> after the WaitForBackgroundWorkerShutdown() function. It turns out that\n> _returns_ inside the PG_TRY()..PG_CATCH() block are *highly* undesirable,\n> since they leave PG_exception_stack pointing to a local struct in a dead\n> frame, which is an obvious UB. I've attached a patch which fixes this\n> behavior in the aforementioned function, but there might be more errors\n> like that elsewhere.\n\nForgot some curly braces, my bad. v2 attached.\n\n-- \nDmitry Ivanov\nPostgres Professional: http://www.postgrespro.com\nRussian Postgres 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","msg_date":"Thu, 04 Aug 2016 14:47:59 +0300","msg_from":"Dmitry Ivanov <d.ivanov@postgrespro.ru>","msg_from_op":true,"msg_subject":"Re: Bug in WaitForBackgroundWorkerShutdown() [REL9_5_STABLE]"},{"msg_contents":"Dmitry Ivanov wrote:\n>> Recently I've encountered a strange crash while calling elog(ERROR, \"...\")\n>> after the WaitForBackgroundWorkerShutdown() function. It turns out that\n>> _returns_ inside the PG_TRY()..PG_CATCH() block are *highly* undesirable,\n>> since they leave PG_exception_stack pointing to a local struct in a dead\n>> frame, which is an obvious UB. I've attached a patch which fixes this\n>> behavior in the aforementioned function, but there might be more errors\n>> like that elsewhere.\n>\n> Forgot some curly braces, my bad. v2 attached.\n>\n\nGood catch. But in 9.6 it has been fixed by \ndb0f6cad4884bd4c835156d3a720d9a79dbd63a9 commit. \n\n\n-- \nYury Zhuravlev\nPostgres Professional: http://www.postgrespro.com\nThe Russian Postgres 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, 04 Aug 2016 15:08:13 +0300","msg_from":"Yury Zhuravlev <u.zhuravlev@postgrespro.ru>","msg_from_op":false,"msg_subject":"Re: Bug in WaitForBackgroundWorkerShutdown()\n =?iso-8859-1?Q?[REL9=5F5=5FSTABLE]?="},{"msg_contents":"Yury Zhuravlev <u.zhuravlev@postgrespro.ru> writes:\n> Dmitry Ivanov wrote:\n>>> Recently I've encountered a strange crash while calling elog(ERROR, \"...\")\n>>> after the WaitForBackgroundWorkerShutdown() function. It turns out that\n>>> _returns_ inside the PG_TRY()..PG_CATCH() block are *highly* undesirable,\n>>> since they leave PG_exception_stack pointing to a local struct in a dead\n>>> frame, which is an obvious UB. I've attached a patch which fixes this\n>>> behavior in the aforementioned function, but there might be more errors\n>>> like that elsewhere.\n\n> Good catch. But in 9.6 it has been fixed by \n> db0f6cad4884bd4c835156d3a720d9a79dbd63a9 commit. \n\nOnly accidentally, I'd say. I chose to push this into HEAD as well,\nso that WaitForBackgroundWorkerShutdown would look more like\nWaitForBackgroundWorkerStartup, and would not have a risk of future\nbreakage if someone adds code after the for-loop.\n\nI was pretty worried about the \"more errors like that\" point, because\nwe recently fixed another similar mistake in plpython, cf 1d2fe56e4.\nHowever, a search using the attached quick-hack script to look for\n\"return\" etc between PG_TRY and PG_CATCH did not find any other\ninstances.\n\nIt'd be nice to have some automatic way of catching future mistakes\nlike this, but I'm not sure about a reliable way to do that.\nOne idea is to add an Assert to PG_CATCH:\n\n #define PG_TRY() \\\n do { \\\n sigjmp_buf *save_exception_stack = PG_exception_stack; \\\n ErrorContextCallback *save_context_stack = error_context_stack; \\\n sigjmp_buf local_sigjmp_buf; \\\n if (sigsetjmp(local_sigjmp_buf, 0) == 0) \\\n { \\\n PG_exception_stack = &local_sigjmp_buf\n \n #define PG_CATCH() \\\n+ Assert(PG_exception_stack == &local_sigjmp_buf); \\\n } \\\n else \\\n { \\\n PG_exception_stack = save_exception_stack; \\\n error_context_stack = save_context_stack\n\nbut there are a couple of disadvantages to this. One is that you don't\nfind out about a problem unless the bad code path is actually exercised.\nI'm afraid that the most tempting places to do something like this would\nbe low-probability error cases, and thus that the Assert would do little\nto catch them. (Case in point: the postmaster-death path fixed in this\npatch would surely never have been caught by testing.) The other and\nreally worse problem is that when the Assert does fire, it's nowhere near\nthe scene of the crime, so while it may tell you there's a problem it\ndoes not give much help in locating the bug.\n\nAnyone have a better idea?\n\n\t\t\tregards, tom lane\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","msg_date":"Thu, 04 Aug 2016 16:19:25 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: Bug in WaitForBackgroundWorkerShutdown()\n =?iso-8859-1?Q?[REL9=5F5=5FSTABLE]?="}],"string":"[\n {\n \"msg_contents\": \"Recently I've encountered a strange crash while calling elog(ERROR, \\\"...\\\") \\nafter the WaitForBackgroundWorkerShutdown() function. It turns out that \\n_returns_ inside the PG_TRY()..PG_CATCH() block are *highly* undesirable, \\nsince they leave PG_exception_stack pointing to a local struct in a dead \\nframe, which is an obvious UB. I've attached a patch which fixes this behavior \\nin the aforementioned function, but there might be more errors like that \\nelsewhere.\\n\\n-- \\nDmitry Ivanov\\nPostgres Professional: http://www.postgrespro.com\\nRussian Postgres 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, 04 Aug 2016 14:44:08 +0300\",\n \"msg_from\": \"Dmitry Ivanov <d.ivanov@postgrespro.ru>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Bug in WaitForBackgroundWorkerShutdown() [REL9_5_STABLE]\"\n },\n {\n \"msg_contents\": \"> Recently I've encountered a strange crash while calling elog(ERROR, \\\"...\\\")\\n> after the WaitForBackgroundWorkerShutdown() function. It turns out that\\n> _returns_ inside the PG_TRY()..PG_CATCH() block are *highly* undesirable,\\n> since they leave PG_exception_stack pointing to a local struct in a dead\\n> frame, which is an obvious UB. I've attached a patch which fixes this\\n> behavior in the aforementioned function, but there might be more errors\\n> like that elsewhere.\\n\\nForgot some curly braces, my bad. v2 attached.\\n\\n-- \\nDmitry Ivanov\\nPostgres Professional: http://www.postgrespro.com\\nRussian Postgres 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, 04 Aug 2016 14:47:59 +0300\",\n \"msg_from\": \"Dmitry Ivanov <d.ivanov@postgrespro.ru>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Bug in WaitForBackgroundWorkerShutdown() [REL9_5_STABLE]\"\n },\n {\n \"msg_contents\": \"Dmitry Ivanov wrote:\\n>> Recently I've encountered a strange crash while calling elog(ERROR, \\\"...\\\")\\n>> after the WaitForBackgroundWorkerShutdown() function. It turns out that\\n>> _returns_ inside the PG_TRY()..PG_CATCH() block are *highly* undesirable,\\n>> since they leave PG_exception_stack pointing to a local struct in a dead\\n>> frame, which is an obvious UB. I've attached a patch which fixes this\\n>> behavior in the aforementioned function, but there might be more errors\\n>> like that elsewhere.\\n>\\n> Forgot some curly braces, my bad. v2 attached.\\n>\\n\\nGood catch. But in 9.6 it has been fixed by \\ndb0f6cad4884bd4c835156d3a720d9a79dbd63a9 commit. \\n\\n\\n-- \\nYury Zhuravlev\\nPostgres Professional: http://www.postgrespro.com\\nThe Russian Postgres 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, 04 Aug 2016 15:08:13 +0300\",\n \"msg_from\": \"Yury Zhuravlev <u.zhuravlev@postgrespro.ru>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Bug in WaitForBackgroundWorkerShutdown()\\n =?iso-8859-1?Q?[REL9=5F5=5FSTABLE]?=\"\n },\n {\n \"msg_contents\": \"Yury Zhuravlev <u.zhuravlev@postgrespro.ru> writes:\\n> Dmitry Ivanov wrote:\\n>>> Recently I've encountered a strange crash while calling elog(ERROR, \\\"...\\\")\\n>>> after the WaitForBackgroundWorkerShutdown() function. It turns out that\\n>>> _returns_ inside the PG_TRY()..PG_CATCH() block are *highly* undesirable,\\n>>> since they leave PG_exception_stack pointing to a local struct in a dead\\n>>> frame, which is an obvious UB. I've attached a patch which fixes this\\n>>> behavior in the aforementioned function, but there might be more errors\\n>>> like that elsewhere.\\n\\n> Good catch. But in 9.6 it has been fixed by \\n> db0f6cad4884bd4c835156d3a720d9a79dbd63a9 commit. \\n\\nOnly accidentally, I'd say. I chose to push this into HEAD as well,\\nso that WaitForBackgroundWorkerShutdown would look more like\\nWaitForBackgroundWorkerStartup, and would not have a risk of future\\nbreakage if someone adds code after the for-loop.\\n\\nI was pretty worried about the \\\"more errors like that\\\" point, because\\nwe recently fixed another similar mistake in plpython, cf 1d2fe56e4.\\nHowever, a search using the attached quick-hack script to look for\\n\\\"return\\\" etc between PG_TRY and PG_CATCH did not find any other\\ninstances.\\n\\nIt'd be nice to have some automatic way of catching future mistakes\\nlike this, but I'm not sure about a reliable way to do that.\\nOne idea is to add an Assert to PG_CATCH:\\n\\n #define PG_TRY() \\\\\\n do { \\\\\\n sigjmp_buf *save_exception_stack = PG_exception_stack; \\\\\\n ErrorContextCallback *save_context_stack = error_context_stack; \\\\\\n sigjmp_buf local_sigjmp_buf; \\\\\\n if (sigsetjmp(local_sigjmp_buf, 0) == 0) \\\\\\n { \\\\\\n PG_exception_stack = &local_sigjmp_buf\\n \\n #define PG_CATCH() \\\\\\n+ Assert(PG_exception_stack == &local_sigjmp_buf); \\\\\\n } \\\\\\n else \\\\\\n { \\\\\\n PG_exception_stack = save_exception_stack; \\\\\\n error_context_stack = save_context_stack\\n\\nbut there are a couple of disadvantages to this. One is that you don't\\nfind out about a problem unless the bad code path is actually exercised.\\nI'm afraid that the most tempting places to do something like this would\\nbe low-probability error cases, and thus that the Assert would do little\\nto catch them. (Case in point: the postmaster-death path fixed in this\\npatch would surely never have been caught by testing.) The other and\\nreally worse problem is that when the Assert does fire, it's nowhere near\\nthe scene of the crime, so while it may tell you there's a problem it\\ndoes not give much help in locating the bug.\\n\\nAnyone have a better idea?\\n\\n\\t\\t\\tregards, tom lane\\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\": \"Thu, 04 Aug 2016 16:19:25 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Bug in WaitForBackgroundWorkerShutdown()\\n =?iso-8859-1?Q?[REL9=5F5=5FSTABLE]?=\"\n }\n]","isConversational":false}}},{"rowIdx":42896,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"I am attaching the patch to improve some coverage of hash index code [1].\nI have added some basic tests, which mainly covers overflow pages. It took\n2 sec extra time in my machine in parallel schedule.\n\n\n\n\nHit Total Coverage\nold tests Line Coverage 780 1478 52.7\n\nFunction Coverage 63 85 74.1\nimprovement after tests Line Coverage 1181 1478 79.9 %\n\nFunction Coverage 78 85 91.8 %\n\n\n[1]Concurrent Hash Index. <https://commitfest.postgresql.org/10/647/>\n\n-- \nThanks and Regards\nMithun C Y\nEnterpriseDB: http://www.enterprisedb.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","msg_date":"Thu, 4 Aug 2016 19:24:03 +0530","msg_from":"Mithun Cy <mithun.cy@enterprisedb.com>","msg_from_op":true,"msg_subject":"\"Some tests to cover hash_index\""},{"msg_contents":"On Thu, Aug 4, 2016 at 7:24 PM, Mithun Cy <mithun.cy@enterprisedb.com>\nwrote:\n\n> I am attaching the patch to improve some coverage of hash index code [1].\n> I have added some basic tests, which mainly covers overflow pages. It took\n> 2 sec extra time in my machine in parallel schedule.\n>\n>\n>\n>\n> Hit Total Coverage\n> old tests Line Coverage 780 1478 52.7\n>\n> Function Coverage 63 85 74.1\n> improvement after tests Line Coverage 1181 1478 79.9 %\n>\n> Function Coverage 78 85 91.8 %\n>\n>\n\nI think the code coverage improvement for hash index with these tests seems\nto be quite good, however time for tests seems to be slightly on higher\nside. Do anybody have better suggestion for these tests?\n\ndiff --git a/src/test/regress/sql/concurrent_hash_index.sql\nb/src/test/regress/sql/concurrent_hash_index.sql\nI wonder why you have included a new file for these tests, why can't be\nthese added to existing hash_index.sql.\n\n+--\n+-- Cause some overflow insert and splits.\n+--\n+CREATE TABLE con_hash_index_table (keycol INT);\n+CREATE INDEX con_hash_index on con_hash_index_table USING HASH (keycol);\n\nThe relation name con_hash_index* choosen in above tests doesn't seem to be\nappropriate, how about hash_split_heap* or something like that.\n\nRegister your patch in latest CF (https://commitfest.postgresql.org/10/)\n\n-- \nWith Regards,\nAmit Kapila.\nEnterpriseDB: http://www.enterprisedb.com\n\nOn Thu, Aug 4, 2016 at 7:24 PM, Mithun Cy <mithun.cy@enterprisedb.com> wrote:I am attaching the patch to improve some coverage of hash index code [1].I have added some basic tests, which mainly covers overflow pages. It took 2 sec extra time in my machine in parallel schedule.\n\n\n\n\n\n\n\n\n\nHit\nTotal\nCoverage\n\n\nold tests\nLine Coverage\n780\n1478\n52.7\n\n\n\nFunction Coverage\n63\n85\n74.1\n\n\nimprovement after tests\nLine Coverage\n1181\n1478\n79.9 %\n\n\n\nFunction Coverage\n78\n85\n91.8 %\n\n\nI think the code coverage improvement for hash index with these tests seems to be quite good, however time for tests seems to be slightly on higher side. Do anybody have better suggestion for these tests?\ndiff --git a/src/test/regress/sql/concurrent_hash_index.sql b/src/test/regress/sql/concurrent_hash_index.sqlI wonder why you have included a new file for these tests, why can't be these added to existing hash_index.sql.+-- +-- Cause some overflow insert and splits.+--+CREATE TABLE con_hash_index_table (keycol INT);+CREATE INDEX con_hash_index on con_hash_index_table USING HASH (keycol);The relation name con_hash_index* choosen in above tests doesn't seem to be appropriate, how about hash_split_heap* or something like that.Register your patch in latest CF (https://commitfest.postgresql.org/10/)-- With Regards,Amit Kapila.EnterpriseDB: http://www.enterprisedb.com","msg_date":"Sat, 6 Aug 2016 09:41:37 +0530","msg_from":"Amit Kapila <amit.kapila16@gmail.com>","msg_from_op":false,"msg_subject":"Re: \"Some tests to cover hash_index\""},{"msg_contents":"Hi All,\n\nI have reverified the code coverage for hash index code using the test file\n(commit-hash_coverage_test) attached with this mailing list and have found\nthat some of the code in _hash_squeezebucket() function flow is not being\ncovered. For this i have added a small testcase on top of 'commit\nhash_coverage_test' patch. I have done this mainly to test Amit's WAL for\nhash index patch [1].\n\nI have also removed the warning message that we used to get for hash index\nlike 'WARNING: hash indexes are not WAL-logged and their use is\ndiscouraged' as this message is now no more visible w.r.t hash index after\nthe WAL patch for hash index. Please have a look and let me know your\nthoughts.\n\n[1] -\nhttps://www.postgresql.org/message-id/CAA4eK1JOBX%3DYU33631Qh-XivYXtPSALh514%2BjR8XeD7v%2BK3r_Q%40mail.gmail.com\n\nWith Regards,\nAshutosh Sharma\nEnterpriseDB:http://www.enterprisedb.com\n\nOn Sat, Aug 6, 2016 at 9:41 AM, Amit Kapila <amit.kapila16@gmail.com> wrote:\n\n> On Thu, Aug 4, 2016 at 7:24 PM, Mithun Cy <mithun.cy@enterprisedb.com>\n> wrote:\n>\n>> I am attaching the patch to improve some coverage of hash index code [1].\n>> I have added some basic tests, which mainly covers overflow pages. It\n>> took 2 sec extra time in my machine in parallel schedule.\n>>\n>>\n>>\n>>\n>> Hit Total Coverage\n>> old tests Line Coverage 780 1478 52.7\n>>\n>> Function Coverage 63 85 74.1\n>> improvement after tests Line Coverage 1181 1478 79.9 %\n>>\n>> Function Coverage 78 85 91.8 %\n>>\n>>\n>\n> I think the code coverage improvement for hash index with these tests\n> seems to be quite good, however time for tests seems to be slightly on\n> higher side. Do anybody have better suggestion for these tests?\n>\n> diff --git a/src/test/regress/sql/concurrent_hash_index.sql\n> b/src/test/regress/sql/concurrent_hash_index.sql\n> I wonder why you have included a new file for these tests, why can't be\n> these added to existing hash_index.sql.\n>\n> +--\n> +-- Cause some overflow insert and splits.\n> +--\n> +CREATE TABLE con_hash_index_table (keycol INT);\n> +CREATE INDEX con_hash_index on con_hash_index_table USING HASH (keycol);\n>\n> The relation name con_hash_index* choosen in above tests doesn't seem to\n> be appropriate, how about hash_split_heap* or something like that.\n>\n> Register your patch in latest CF (https://commitfest.postgresql.org/10/)\n>\n> --\n> With Regards,\n> Amit Kapila.\n> EnterpriseDB: http://www.enterprisedb.com\n>\n\nHi All,I have reverified the code coverage for hash index code \nusing the test file (commit-hash_coverage_test) attached with this \nmailing list and have found that some of the code in \n_hash_squeezebucket() function flow is not being covered. For this i \nhave added a small testcase on top of 'commit hash_coverage_test' patch. I\n have done this mainly to test Amit's WAL for hash index patch [1].I\n have also removed the warning message that we used to get for hash \nindex like 'WARNING: hash indexes are not WAL-logged and their use is \ndiscouraged' as this message is now no more visible w.r.t hash index \nafter the WAL patch for hash index. Please have a look and let me know \nyour thoughts.[1] - https://www.postgresql.org/message-id/CAA4eK1JOBX%3DYU33631Qh-XivYXtPSALh514%2BjR8XeD7v%2BK3r_Q%40mail.gmail.comWith Regards,Ashutosh SharmaEnterpriseDB:http://www.enterprisedb.comOn Sat, Aug 6, 2016 at 9:41 AM, Amit Kapila <amit.kapila16@gmail.com> wrote:On Thu, Aug 4, 2016 at 7:24 PM, Mithun Cy <mithun.cy@enterprisedb.com> wrote:I am attaching the patch to improve some coverage of hash index code [1].I have added some basic tests, which mainly covers overflow pages. It took 2 sec extra time in my machine in parallel schedule.\n\n\n\n\n\n\n\n\n\nHit\nTotal\nCoverage\n\n\nold tests\nLine Coverage\n780\n1478\n52.7\n\n\n\nFunction Coverage\n63\n85\n74.1\n\n\nimprovement after tests\nLine Coverage\n1181\n1478\n79.9 %\n\n\n\nFunction Coverage\n78\n85\n91.8 %\n\n\nI think the code coverage improvement for hash index with these tests seems to be quite good, however time for tests seems to be slightly on higher side. Do anybody have better suggestion for these tests?\ndiff --git a/src/test/regress/sql/concurrent_hash_index.sql b/src/test/regress/sql/concurrent_hash_index.sqlI wonder why you have included a new file for these tests, why can't be these added to existing hash_index.sql.+-- +-- Cause some overflow insert and splits.+--+CREATE TABLE con_hash_index_table (keycol INT);+CREATE INDEX con_hash_index on con_hash_index_table USING HASH (keycol);The relation name con_hash_index* choosen in above tests doesn't seem to be appropriate, how about hash_split_heap* or something like that.Register your patch in latest CF (https://commitfest.postgresql.org/10/)-- With Regards,Amit Kapila.EnterpriseDB: http://www.enterprisedb.com","msg_date":"Tue, 23 Aug 2016 11:47:35 +0530","msg_from":"Ashutosh Sharma <ashu.coek88@gmail.com>","msg_from_op":false,"msg_subject":"Re: \"Some tests to cover hash_index\""},{"msg_contents":"Hi,\n\nI missed to attach the patch in my previous mail. Here i attach the patch.\n\nWith Regards,\nAshutosh Sharma\nEnterpriseDB:http://www.enterprisedb.com\n\nOn Tue, Aug 23, 2016 at 11:47 AM, Ashutosh Sharma <ashu.coek88@gmail.com>\nwrote:\n\n> Hi All,\n>\n> I have reverified the code coverage for hash index code using the test\n> file (commit-hash_coverage_test) attached with this mailing list and have\n> found that some of the code in _hash_squeezebucket() function flow is not\n> being covered. For this i have added a small testcase on top of 'commit\n> hash_coverage_test' patch. I have done this mainly to test Amit's WAL for\n> hash index patch [1].\n>\n> I have also removed the warning message that we used to get for hash index\n> like 'WARNING: hash indexes are not WAL-logged and their use is\n> discouraged' as this message is now no more visible w.r.t hash index after\n> the WAL patch for hash index. Please have a look and let me know your\n> thoughts.\n>\n> [1] - https://www.postgresql.org/message-id/CAA4eK1JOBX%\n> 3DYU33631Qh-XivYXtPSALh514%2BjR8XeD7v%2BK3r_Q%40mail.gmail.com\n>\n> With Regards,\n> Ashutosh Sharma\n> EnterpriseDB:http://www.enterprisedb.com\n>\n> On Sat, Aug 6, 2016 at 9:41 AM, Amit Kapila <amit.kapila16@gmail.com>\n> wrote:\n>\n>> On Thu, Aug 4, 2016 at 7:24 PM, Mithun Cy <mithun.cy@enterprisedb.com>\n>> wrote:\n>>\n>>> I am attaching the patch to improve some coverage of hash index code [1].\n>>> I have added some basic tests, which mainly covers overflow pages. It\n>>> took 2 sec extra time in my machine in parallel schedule.\n>>>\n>>>\n>>>\n>>>\n>>> Hit Total Coverage\n>>> old tests Line Coverage 780 1478 52.7\n>>>\n>>> Function Coverage 63 85 74.1\n>>> improvement after tests Line Coverage 1181 1478 79.9 %\n>>>\n>>> Function Coverage 78 85 91.8 %\n>>>\n>>>\n>>\n>> I think the code coverage improvement for hash index with these tests\n>> seems to be quite good, however time for tests seems to be slightly on\n>> higher side. Do anybody have better suggestion for these tests?\n>>\n>> diff --git a/src/test/regress/sql/concurrent_hash_index.sql\n>> b/src/test/regress/sql/concurrent_hash_index.sql\n>> I wonder why you have included a new file for these tests, why can't be\n>> these added to existing hash_index.sql.\n>>\n>> +--\n>> +-- Cause some overflow insert and splits.\n>> +--\n>> +CREATE TABLE con_hash_index_table (keycol INT);\n>> +CREATE INDEX con_hash_index on con_hash_index_table USING HASH (keycol);\n>>\n>> The relation name con_hash_index* choosen in above tests doesn't seem to\n>> be appropriate, how about hash_split_heap* or something like that.\n>>\n>> Register your patch in latest CF (https://commitfest.postgresql.org/10/)\n>>\n>> --\n>> With Regards,\n>> Amit Kapila.\n>> EnterpriseDB: http://www.enterprisedb.com\n>>\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","msg_date":"Tue, 23 Aug 2016 12:00:23 +0530","msg_from":"Ashutosh Sharma <ashu.coek88@gmail.com>","msg_from_op":false,"msg_subject":"Re: \"Some tests to cover hash_index\""},{"msg_contents":"On Tue, Aug 23, 2016 at 2:17 AM, Ashutosh Sharma <ashu.coek88@gmail.com> wrote:\n> I have also removed the warning message that we used to get for hash index like 'WARNING: hash indexes are not WAL-logged and their use is discouraged' as this message is now no more visible w.r.t hash index after the WAL patch for hash index. Please have a look and let me know your thoughts.\n\nWell, that change should be part of Amit's patch to add WAL logging,\nnot this patch, whose mission is just to improve test coverage.\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, 23 Aug 2016 10:09:11 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: \"Some tests to cover hash_index\""},{"msg_contents":"Hi,\n\n> Well, that change should be part of Amit's patch to add WAL logging,\n> not this patch, whose mission is just to improve test coverage.\n\nI have just removed the warning message from expected output file as i\nhave performed the testing on Amit's latest patch that removes this\nwarning message from the hash index code.\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, 24 Aug 2016 11:38:38 +0530","msg_from":"Ashutosh Sharma <ashu.coek88@gmail.com>","msg_from_op":false,"msg_subject":"Re: \"Some tests to cover hash_index\""},{"msg_contents":"On Wed, Aug 24, 2016 at 11:38 AM, Ashutosh Sharma <ashu.coek88@gmail.com> wrote:\n> Hi,\n>\n>> Well, that change should be part of Amit's patch to add WAL logging,\n>> not this patch, whose mission is just to improve test coverage.\n>\n> I have just removed the warning message from expected output file as i\n> have performed the testing on Amit's latest patch that removes this\n> warning message from the hash index code.\n>\n\nI think you are missing what Robert wants to point out. You don't\nneed to remove the warning message when you are adding new test cases\non top of Mithun's patch even if those new tests helps to cover the\ncode path which is required for wal-hash-index patch.\n\n-- \nWith Regards,\nAmit Kapila.\nEnterpriseDB: http://www.enterprisedb.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, 24 Aug 2016 12:04:25 +0530","msg_from":"Amit Kapila <amit.kapila16@gmail.com>","msg_from_op":false,"msg_subject":"Re: \"Some tests to cover hash_index\""},{"msg_contents":"On Wed, Aug 24, 2016 at 2:34 AM, Amit Kapila <amit.kapila16@gmail.com> wrote:\n> On Wed, Aug 24, 2016 at 11:38 AM, Ashutosh Sharma <ashu.coek88@gmail.com> wrote:\n>>> Well, that change should be part of Amit's patch to add WAL logging,\n>>> not this patch, whose mission is just to improve test coverage.\n>>\n>> I have just removed the warning message from expected output file as i\n>> have performed the testing on Amit's latest patch that removes this\n>> warning message from the hash index code.\n>>\n>\n> I think you are missing what Robert wants to point out. You don't\n> need to remove the warning message when you are adding new test cases\n> on top of Mithun's patch even if those new tests helps to cover the\n> code path which is required for wal-hash-index patch.\n\nRight. The point is, if somebody applies this patch on top of master,\nthe regression tests will now fail because of that missing line. That\nmeans nobody is going to commit this.\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, 24 Aug 2016 12:48:19 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: \"Some tests to cover hash_index\""},{"msg_contents":"On Sat, Aug 6, 2016 at 9:41 AM, Amit Kapila <amit.kapila16@gmail.com> wrote:\n> I wonder why you have included a new file for these tests, why can't be\nthese added to existing hash_index.sql.\ntests in hash_index.sql did not cover overflow pages, above tests were for\nmainly for them. So I thought having a separate test file can help\nenabling/disabling them in schedule files, when we do not want them running\nas it take slightly high time. If you think otherwise I will reconsider\nwill add tests to hash_index.sql.\n\n>The relation name con_hash_index* choosen in above tests doesn't seem to\nbe appropriate, how about hash_split_heap* or something like that.\nFixed. Have renamed relation, index and test filename accordingly.\n\n-- \nThanks and Regards\nMithun C Y\nEnterpriseDB: http://www.enterprisedb.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","msg_date":"Mon, 19 Sep 2016 20:44:37 +0530","msg_from":"Mithun Cy <mithun.cy@enterprisedb.com>","msg_from_op":true,"msg_subject":"Re: \"Some tests to cover hash_index\""},{"msg_contents":"On Mon, Sep 19, 2016 at 8:44 PM, Mithun Cy <mithun.cy@enterprisedb.com> wrote:\n> On Sat, Aug 6, 2016 at 9:41 AM, Amit Kapila <amit.kapila16@gmail.com> wrote:\n>> I wonder why you have included a new file for these tests, why can't be\n>> these added to existing hash_index.sql.\n> tests in hash_index.sql did not cover overflow pages, above tests were for\n> mainly for them.\n>\n\nThe name of file hash_index_split suggests it focus on split. Are the\ntests focussed more on overflow pages or on split of hash index?\n\n So I thought having a separate test file can help\n> enabling/disabling them in schedule files, when we do not want them running\n> as it take slightly high time. If you think otherwise I will reconsider will\n> add tests to hash_index.sql.\n>\n\nI think you have a point, but not sure if it is worth to add a\nseparate file. It might be tricky to choose which file to add new\ntests for hash_indexes. Anybody else have opinion on this point?\n\nCan you check how much time it takes as compare to btree or brin index tests?\n\nI am facing below diff with your new patch.\n\n***************\n*** 1,4 ****\n! --\n -- Cause some overflow insert and splits.\n --\n CREATE TABLE hash_split_heap (keycol INT);\n--- 1,4 ----\n! --\n -- Cause some overflow insert and splits.\n --\n CREATE TABLE hash_split_heap (keycol INT);\n\n======================================================================\n\nThere is an extra space in expected file which is leading to above failure.\n\n-- \nWith Regards,\nAmit Kapila.\nEnterpriseDB: http://www.enterprisedb.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, 20 Sep 2016 18:22:23 +0530","msg_from":"Amit Kapila <amit.kapila16@gmail.com>","msg_from_op":false,"msg_subject":"Re: \"Some tests to cover hash_index\""},{"msg_contents":"On Tue, Sep 20, 2016 at 8:52 AM, Amit Kapila <amit.kapila16@gmail.com> wrote:\n> I think you have a point, but not sure if it is worth to add a\n> separate file. It might be tricky to choose which file to add new\n> tests for hash_indexes. Anybody else have opinion on this point?\n\nI think all the tests should be added to hash_index.sql. A new file\ndoesn't seem warranted.\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, 20 Sep 2016 11:25:11 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: \"Some tests to cover hash_index\""},{"msg_contents":"\nWhy not use generate_series() queries to insert the appropriate number\nof tuples, instead of a handful of INSERT lines each time? Since each\ninsert is a separate transaction, that would probably be faster.\n\nWhy do you have a plpgsql function just to create a cursor? Wouldn't it\nbe simpler to create the cursor in an SQL statement?\n\n-- \n�lvaro Herrera https://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, 20 Sep 2016 15:26:29 -0300","msg_from":"Alvaro Herrera <alvherre@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: \"Some tests to cover hash_index\""},{"msg_contents":"On Tue, Sep 20, 2016 at 2:26 PM, Alvaro Herrera\n<alvherre@2ndquadrant.com> wrote:\n> Why not use generate_series() queries to insert the appropriate number\n> of tuples, instead of a handful of INSERT lines each time? Since each\n> insert is a separate transaction, that would probably be faster.\n>\n> Why do you have a plpgsql function just to create a cursor? Wouldn't it\n> be simpler to create the cursor in an SQL statement?\n\nThis patch hasn't been updated in over a week, so I'm marking it\nReturned with Feedback. I think this is a good effort and I hope\nsomething committable will come from it, but with 2 days left it's not\ngoing to happen this CF.\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, 28 Sep 2016 12:26:29 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: \"Some tests to cover hash_index\""},{"msg_contents":"On Wed, Sep 28, 2016 at 9:56 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n> something committable will come from it, but with 2 days left it's not\n> going to happen this CF.\nAdding a new patch. This one uses generate series instead of INSERT INTO\nSELECT and fixed comments from Alvaro.\n\n-- \nThanks and Regards\nMithun C Y\nEnterpriseDB: http://www.enterprisedb.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","msg_date":"Wed, 12 Oct 2016 10:47:43 +0530","msg_from":"Mithun Cy <mithun.cy@enterprisedb.com>","msg_from_op":true,"msg_subject":"Re: \"Some tests to cover hash_index\""},{"msg_contents":"On Wed, Oct 12, 2016 at 1:17 AM, Mithun Cy <mithun.cy@enterprisedb.com> wrote:\n> On Wed, Sep 28, 2016 at 9:56 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n>> something committable will come from it, but with 2 days left it's not\n>> going to happen this CF.\n> Adding a new patch. This one uses generate series instead of INSERT INTO\n> SELECT and fixed comments from Alvaro.\n\nCommitted.\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, 18 Oct 2016 16:00:37 -0400","msg_from":"Robert Haas <robertmhaas@gmail.com>","msg_from_op":false,"msg_subject":"Re: \"Some tests to cover hash_index\""}],"string":"[\n {\n \"msg_contents\": \"I am attaching the patch to improve some coverage of hash index code [1].\\nI have added some basic tests, which mainly covers overflow pages. It took\\n2 sec extra time in my machine in parallel schedule.\\n\\n\\n\\n\\nHit Total Coverage\\nold tests Line Coverage 780 1478 52.7\\n\\nFunction Coverage 63 85 74.1\\nimprovement after tests Line Coverage 1181 1478 79.9 %\\n\\nFunction Coverage 78 85 91.8 %\\n\\n\\n[1]Concurrent Hash Index. <https://commitfest.postgresql.org/10/647/>\\n\\n-- \\nThanks and Regards\\nMithun C Y\\nEnterpriseDB: http://www.enterprisedb.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\": \"Thu, 4 Aug 2016 19:24:03 +0530\",\n \"msg_from\": \"Mithun Cy <mithun.cy@enterprisedb.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"\\\"Some tests to cover hash_index\\\"\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 7:24 PM, Mithun Cy <mithun.cy@enterprisedb.com>\\nwrote:\\n\\n> I am attaching the patch to improve some coverage of hash index code [1].\\n> I have added some basic tests, which mainly covers overflow pages. It took\\n> 2 sec extra time in my machine in parallel schedule.\\n>\\n>\\n>\\n>\\n> Hit Total Coverage\\n> old tests Line Coverage 780 1478 52.7\\n>\\n> Function Coverage 63 85 74.1\\n> improvement after tests Line Coverage 1181 1478 79.9 %\\n>\\n> Function Coverage 78 85 91.8 %\\n>\\n>\\n\\nI think the code coverage improvement for hash index with these tests seems\\nto be quite good, however time for tests seems to be slightly on higher\\nside. Do anybody have better suggestion for these tests?\\n\\ndiff --git a/src/test/regress/sql/concurrent_hash_index.sql\\nb/src/test/regress/sql/concurrent_hash_index.sql\\nI wonder why you have included a new file for these tests, why can't be\\nthese added to existing hash_index.sql.\\n\\n+--\\n+-- Cause some overflow insert and splits.\\n+--\\n+CREATE TABLE con_hash_index_table (keycol INT);\\n+CREATE INDEX con_hash_index on con_hash_index_table USING HASH (keycol);\\n\\nThe relation name con_hash_index* choosen in above tests doesn't seem to be\\nappropriate, how about hash_split_heap* or something like that.\\n\\nRegister your patch in latest CF (https://commitfest.postgresql.org/10/)\\n\\n-- \\nWith Regards,\\nAmit Kapila.\\nEnterpriseDB: http://www.enterprisedb.com\\n\\nOn Thu, Aug 4, 2016 at 7:24 PM, Mithun Cy <mithun.cy@enterprisedb.com> wrote:I am attaching the patch to improve some coverage of hash index code [1].I have added some basic tests, which mainly covers overflow pages. It took 2 sec extra time in my machine in parallel schedule.\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nHit\\nTotal\\nCoverage\\n\\n\\nold tests\\nLine Coverage\\n780\\n1478\\n52.7\\n\\n\\n\\nFunction Coverage\\n63\\n85\\n74.1\\n\\n\\nimprovement after tests\\nLine Coverage\\n1181\\n1478\\n79.9 %\\n\\n\\n\\nFunction Coverage\\n78\\n85\\n91.8 %\\n\\n\\nI think the code coverage improvement for hash index with these tests seems to be quite good, however time for tests seems to be slightly on higher side. Do anybody have better suggestion for these tests?\\ndiff --git a/src/test/regress/sql/concurrent_hash_index.sql b/src/test/regress/sql/concurrent_hash_index.sqlI wonder why you have included a new file for these tests, why can't be these added to existing hash_index.sql.+-- +-- Cause some overflow insert and splits.+--+CREATE TABLE con_hash_index_table (keycol INT);+CREATE INDEX con_hash_index on con_hash_index_table USING HASH (keycol);The relation name con_hash_index* choosen in above tests doesn't seem to be appropriate, how about hash_split_heap* or something like that.Register your patch in latest CF (https://commitfest.postgresql.org/10/)-- With Regards,Amit Kapila.EnterpriseDB: http://www.enterprisedb.com\",\n \"msg_date\": \"Sat, 6 Aug 2016 09:41:37 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: \\\"Some tests to cover hash_index\\\"\"\n },\n {\n \"msg_contents\": \"Hi All,\\n\\nI have reverified the code coverage for hash index code using the test file\\n(commit-hash_coverage_test) attached with this mailing list and have found\\nthat some of the code in _hash_squeezebucket() function flow is not being\\ncovered. For this i have added a small testcase on top of 'commit\\nhash_coverage_test' patch. I have done this mainly to test Amit's WAL for\\nhash index patch [1].\\n\\nI have also removed the warning message that we used to get for hash index\\nlike 'WARNING: hash indexes are not WAL-logged and their use is\\ndiscouraged' as this message is now no more visible w.r.t hash index after\\nthe WAL patch for hash index. Please have a look and let me know your\\nthoughts.\\n\\n[1] -\\nhttps://www.postgresql.org/message-id/CAA4eK1JOBX%3DYU33631Qh-XivYXtPSALh514%2BjR8XeD7v%2BK3r_Q%40mail.gmail.com\\n\\nWith Regards,\\nAshutosh Sharma\\nEnterpriseDB:http://www.enterprisedb.com\\n\\nOn Sat, Aug 6, 2016 at 9:41 AM, Amit Kapila <amit.kapila16@gmail.com> wrote:\\n\\n> On Thu, Aug 4, 2016 at 7:24 PM, Mithun Cy <mithun.cy@enterprisedb.com>\\n> wrote:\\n>\\n>> I am attaching the patch to improve some coverage of hash index code [1].\\n>> I have added some basic tests, which mainly covers overflow pages. It\\n>> took 2 sec extra time in my machine in parallel schedule.\\n>>\\n>>\\n>>\\n>>\\n>> Hit Total Coverage\\n>> old tests Line Coverage 780 1478 52.7\\n>>\\n>> Function Coverage 63 85 74.1\\n>> improvement after tests Line Coverage 1181 1478 79.9 %\\n>>\\n>> Function Coverage 78 85 91.8 %\\n>>\\n>>\\n>\\n> I think the code coverage improvement for hash index with these tests\\n> seems to be quite good, however time for tests seems to be slightly on\\n> higher side. Do anybody have better suggestion for these tests?\\n>\\n> diff --git a/src/test/regress/sql/concurrent_hash_index.sql\\n> b/src/test/regress/sql/concurrent_hash_index.sql\\n> I wonder why you have included a new file for these tests, why can't be\\n> these added to existing hash_index.sql.\\n>\\n> +--\\n> +-- Cause some overflow insert and splits.\\n> +--\\n> +CREATE TABLE con_hash_index_table (keycol INT);\\n> +CREATE INDEX con_hash_index on con_hash_index_table USING HASH (keycol);\\n>\\n> The relation name con_hash_index* choosen in above tests doesn't seem to\\n> be appropriate, how about hash_split_heap* or something like that.\\n>\\n> Register your patch in latest CF (https://commitfest.postgresql.org/10/)\\n>\\n> --\\n> With Regards,\\n> Amit Kapila.\\n> EnterpriseDB: http://www.enterprisedb.com\\n>\\n\\nHi All,I have reverified the code coverage for hash index code \\nusing the test file (commit-hash_coverage_test) attached with this \\nmailing list and have found that some of the code in \\n_hash_squeezebucket() function flow is not being covered. For this i \\nhave added a small testcase on top of 'commit hash_coverage_test' patch. I\\n have done this mainly to test Amit's WAL for hash index patch [1].I\\n have also removed the warning message that we used to get for hash \\nindex like 'WARNING: hash indexes are not WAL-logged and their use is \\ndiscouraged' as this message is now no more visible w.r.t hash index \\nafter the WAL patch for hash index. Please have a look and let me know \\nyour thoughts.[1] - https://www.postgresql.org/message-id/CAA4eK1JOBX%3DYU33631Qh-XivYXtPSALh514%2BjR8XeD7v%2BK3r_Q%40mail.gmail.comWith Regards,Ashutosh SharmaEnterpriseDB:http://www.enterprisedb.comOn Sat, Aug 6, 2016 at 9:41 AM, Amit Kapila <amit.kapila16@gmail.com> wrote:On Thu, Aug 4, 2016 at 7:24 PM, Mithun Cy <mithun.cy@enterprisedb.com> wrote:I am attaching the patch to improve some coverage of hash index code [1].I have added some basic tests, which mainly covers overflow pages. It took 2 sec extra time in my machine in parallel schedule.\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nHit\\nTotal\\nCoverage\\n\\n\\nold tests\\nLine Coverage\\n780\\n1478\\n52.7\\n\\n\\n\\nFunction Coverage\\n63\\n85\\n74.1\\n\\n\\nimprovement after tests\\nLine Coverage\\n1181\\n1478\\n79.9 %\\n\\n\\n\\nFunction Coverage\\n78\\n85\\n91.8 %\\n\\n\\nI think the code coverage improvement for hash index with these tests seems to be quite good, however time for tests seems to be slightly on higher side. Do anybody have better suggestion for these tests?\\ndiff --git a/src/test/regress/sql/concurrent_hash_index.sql b/src/test/regress/sql/concurrent_hash_index.sqlI wonder why you have included a new file for these tests, why can't be these added to existing hash_index.sql.+-- +-- Cause some overflow insert and splits.+--+CREATE TABLE con_hash_index_table (keycol INT);+CREATE INDEX con_hash_index on con_hash_index_table USING HASH (keycol);The relation name con_hash_index* choosen in above tests doesn't seem to be appropriate, how about hash_split_heap* or something like that.Register your patch in latest CF (https://commitfest.postgresql.org/10/)-- With Regards,Amit Kapila.EnterpriseDB: http://www.enterprisedb.com\",\n \"msg_date\": \"Tue, 23 Aug 2016 11:47:35 +0530\",\n \"msg_from\": \"Ashutosh Sharma <ashu.coek88@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: \\\"Some tests to cover hash_index\\\"\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\nI missed to attach the patch in my previous mail. Here i attach the patch.\\n\\nWith Regards,\\nAshutosh Sharma\\nEnterpriseDB:http://www.enterprisedb.com\\n\\nOn Tue, Aug 23, 2016 at 11:47 AM, Ashutosh Sharma <ashu.coek88@gmail.com>\\nwrote:\\n\\n> Hi All,\\n>\\n> I have reverified the code coverage for hash index code using the test\\n> file (commit-hash_coverage_test) attached with this mailing list and have\\n> found that some of the code in _hash_squeezebucket() function flow is not\\n> being covered. For this i have added a small testcase on top of 'commit\\n> hash_coverage_test' patch. I have done this mainly to test Amit's WAL for\\n> hash index patch [1].\\n>\\n> I have also removed the warning message that we used to get for hash index\\n> like 'WARNING: hash indexes are not WAL-logged and their use is\\n> discouraged' as this message is now no more visible w.r.t hash index after\\n> the WAL patch for hash index. Please have a look and let me know your\\n> thoughts.\\n>\\n> [1] - https://www.postgresql.org/message-id/CAA4eK1JOBX%\\n> 3DYU33631Qh-XivYXtPSALh514%2BjR8XeD7v%2BK3r_Q%40mail.gmail.com\\n>\\n> With Regards,\\n> Ashutosh Sharma\\n> EnterpriseDB:http://www.enterprisedb.com\\n>\\n> On Sat, Aug 6, 2016 at 9:41 AM, Amit Kapila <amit.kapila16@gmail.com>\\n> wrote:\\n>\\n>> On Thu, Aug 4, 2016 at 7:24 PM, Mithun Cy <mithun.cy@enterprisedb.com>\\n>> wrote:\\n>>\\n>>> I am attaching the patch to improve some coverage of hash index code [1].\\n>>> I have added some basic tests, which mainly covers overflow pages. It\\n>>> took 2 sec extra time in my machine in parallel schedule.\\n>>>\\n>>>\\n>>>\\n>>>\\n>>> Hit Total Coverage\\n>>> old tests Line Coverage 780 1478 52.7\\n>>>\\n>>> Function Coverage 63 85 74.1\\n>>> improvement after tests Line Coverage 1181 1478 79.9 %\\n>>>\\n>>> Function Coverage 78 85 91.8 %\\n>>>\\n>>>\\n>>\\n>> I think the code coverage improvement for hash index with these tests\\n>> seems to be quite good, however time for tests seems to be slightly on\\n>> higher side. Do anybody have better suggestion for these tests?\\n>>\\n>> diff --git a/src/test/regress/sql/concurrent_hash_index.sql\\n>> b/src/test/regress/sql/concurrent_hash_index.sql\\n>> I wonder why you have included a new file for these tests, why can't be\\n>> these added to existing hash_index.sql.\\n>>\\n>> +--\\n>> +-- Cause some overflow insert and splits.\\n>> +--\\n>> +CREATE TABLE con_hash_index_table (keycol INT);\\n>> +CREATE INDEX con_hash_index on con_hash_index_table USING HASH (keycol);\\n>>\\n>> The relation name con_hash_index* choosen in above tests doesn't seem to\\n>> be appropriate, how about hash_split_heap* or something like that.\\n>>\\n>> Register your patch in latest CF (https://commitfest.postgresql.org/10/)\\n>>\\n>> --\\n>> With Regards,\\n>> Amit Kapila.\\n>> EnterpriseDB: http://www.enterprisedb.com\\n>>\\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, 23 Aug 2016 12:00:23 +0530\",\n \"msg_from\": \"Ashutosh Sharma <ashu.coek88@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: \\\"Some tests to cover hash_index\\\"\"\n },\n {\n \"msg_contents\": \"On Tue, Aug 23, 2016 at 2:17 AM, Ashutosh Sharma <ashu.coek88@gmail.com> wrote:\\n> I have also removed the warning message that we used to get for hash index like 'WARNING: hash indexes are not WAL-logged and their use is discouraged' as this message is now no more visible w.r.t hash index after the WAL patch for hash index. Please have a look and let me know your thoughts.\\n\\nWell, that change should be part of Amit's patch to add WAL logging,\\nnot this patch, whose mission is just to improve test coverage.\\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, 23 Aug 2016 10:09:11 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: \\\"Some tests to cover hash_index\\\"\"\n },\n {\n \"msg_contents\": \"Hi,\\n\\n> Well, that change should be part of Amit's patch to add WAL logging,\\n> not this patch, whose mission is just to improve test coverage.\\n\\nI have just removed the warning message from expected output file as i\\nhave performed the testing on Amit's latest patch that removes this\\nwarning message from the hash index code.\\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, 24 Aug 2016 11:38:38 +0530\",\n \"msg_from\": \"Ashutosh Sharma <ashu.coek88@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: \\\"Some tests to cover hash_index\\\"\"\n },\n {\n \"msg_contents\": \"On Wed, Aug 24, 2016 at 11:38 AM, Ashutosh Sharma <ashu.coek88@gmail.com> wrote:\\n> Hi,\\n>\\n>> Well, that change should be part of Amit's patch to add WAL logging,\\n>> not this patch, whose mission is just to improve test coverage.\\n>\\n> I have just removed the warning message from expected output file as i\\n> have performed the testing on Amit's latest patch that removes this\\n> warning message from the hash index code.\\n>\\n\\nI think you are missing what Robert wants to point out. You don't\\nneed to remove the warning message when you are adding new test cases\\non top of Mithun's patch even if those new tests helps to cover the\\ncode path which is required for wal-hash-index patch.\\n\\n-- \\nWith Regards,\\nAmit Kapila.\\nEnterpriseDB: http://www.enterprisedb.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, 24 Aug 2016 12:04:25 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: \\\"Some tests to cover hash_index\\\"\"\n },\n {\n \"msg_contents\": \"On Wed, Aug 24, 2016 at 2:34 AM, Amit Kapila <amit.kapila16@gmail.com> wrote:\\n> On Wed, Aug 24, 2016 at 11:38 AM, Ashutosh Sharma <ashu.coek88@gmail.com> wrote:\\n>>> Well, that change should be part of Amit's patch to add WAL logging,\\n>>> not this patch, whose mission is just to improve test coverage.\\n>>\\n>> I have just removed the warning message from expected output file as i\\n>> have performed the testing on Amit's latest patch that removes this\\n>> warning message from the hash index code.\\n>>\\n>\\n> I think you are missing what Robert wants to point out. You don't\\n> need to remove the warning message when you are adding new test cases\\n> on top of Mithun's patch even if those new tests helps to cover the\\n> code path which is required for wal-hash-index patch.\\n\\nRight. The point is, if somebody applies this patch on top of master,\\nthe regression tests will now fail because of that missing line. That\\nmeans nobody is going to commit this.\\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, 24 Aug 2016 12:48:19 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: \\\"Some tests to cover hash_index\\\"\"\n },\n {\n \"msg_contents\": \"On Sat, Aug 6, 2016 at 9:41 AM, Amit Kapila <amit.kapila16@gmail.com> wrote:\\n> I wonder why you have included a new file for these tests, why can't be\\nthese added to existing hash_index.sql.\\ntests in hash_index.sql did not cover overflow pages, above tests were for\\nmainly for them. So I thought having a separate test file can help\\nenabling/disabling them in schedule files, when we do not want them running\\nas it take slightly high time. If you think otherwise I will reconsider\\nwill add tests to hash_index.sql.\\n\\n>The relation name con_hash_index* choosen in above tests doesn't seem to\\nbe appropriate, how about hash_split_heap* or something like that.\\nFixed. Have renamed relation, index and test filename accordingly.\\n\\n-- \\nThanks and Regards\\nMithun C Y\\nEnterpriseDB: http://www.enterprisedb.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, 19 Sep 2016 20:44:37 +0530\",\n \"msg_from\": \"Mithun Cy <mithun.cy@enterprisedb.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: \\\"Some tests to cover hash_index\\\"\"\n },\n {\n \"msg_contents\": \"On Mon, Sep 19, 2016 at 8:44 PM, Mithun Cy <mithun.cy@enterprisedb.com> wrote:\\n> On Sat, Aug 6, 2016 at 9:41 AM, Amit Kapila <amit.kapila16@gmail.com> wrote:\\n>> I wonder why you have included a new file for these tests, why can't be\\n>> these added to existing hash_index.sql.\\n> tests in hash_index.sql did not cover overflow pages, above tests were for\\n> mainly for them.\\n>\\n\\nThe name of file hash_index_split suggests it focus on split. Are the\\ntests focussed more on overflow pages or on split of hash index?\\n\\n So I thought having a separate test file can help\\n> enabling/disabling them in schedule files, when we do not want them running\\n> as it take slightly high time. If you think otherwise I will reconsider will\\n> add tests to hash_index.sql.\\n>\\n\\nI think you have a point, but not sure if it is worth to add a\\nseparate file. It might be tricky to choose which file to add new\\ntests for hash_indexes. Anybody else have opinion on this point?\\n\\nCan you check how much time it takes as compare to btree or brin index tests?\\n\\nI am facing below diff with your new patch.\\n\\n***************\\n*** 1,4 ****\\n! --\\n -- Cause some overflow insert and splits.\\n --\\n CREATE TABLE hash_split_heap (keycol INT);\\n--- 1,4 ----\\n! --\\n -- Cause some overflow insert and splits.\\n --\\n CREATE TABLE hash_split_heap (keycol INT);\\n\\n======================================================================\\n\\nThere is an extra space in expected file which is leading to above failure.\\n\\n-- \\nWith Regards,\\nAmit Kapila.\\nEnterpriseDB: http://www.enterprisedb.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, 20 Sep 2016 18:22:23 +0530\",\n \"msg_from\": \"Amit Kapila <amit.kapila16@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: \\\"Some tests to cover hash_index\\\"\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 20, 2016 at 8:52 AM, Amit Kapila <amit.kapila16@gmail.com> wrote:\\n> I think you have a point, but not sure if it is worth to add a\\n> separate file. It might be tricky to choose which file to add new\\n> tests for hash_indexes. Anybody else have opinion on this point?\\n\\nI think all the tests should be added to hash_index.sql. A new file\\ndoesn't seem warranted.\\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, 20 Sep 2016 11:25:11 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: \\\"Some tests to cover hash_index\\\"\"\n },\n {\n \"msg_contents\": \"\\nWhy not use generate_series() queries to insert the appropriate number\\nof tuples, instead of a handful of INSERT lines each time? Since each\\ninsert is a separate transaction, that would probably be faster.\\n\\nWhy do you have a plpgsql function just to create a cursor? Wouldn't it\\nbe simpler to create the cursor in an SQL statement?\\n\\n-- \\n�lvaro Herrera https://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, 20 Sep 2016 15:26:29 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: \\\"Some tests to cover hash_index\\\"\"\n },\n {\n \"msg_contents\": \"On Tue, Sep 20, 2016 at 2:26 PM, Alvaro Herrera\\n<alvherre@2ndquadrant.com> wrote:\\n> Why not use generate_series() queries to insert the appropriate number\\n> of tuples, instead of a handful of INSERT lines each time? Since each\\n> insert is a separate transaction, that would probably be faster.\\n>\\n> Why do you have a plpgsql function just to create a cursor? Wouldn't it\\n> be simpler to create the cursor in an SQL statement?\\n\\nThis patch hasn't been updated in over a week, so I'm marking it\\nReturned with Feedback. I think this is a good effort and I hope\\nsomething committable will come from it, but with 2 days left it's not\\ngoing to happen this CF.\\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, 28 Sep 2016 12:26:29 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: \\\"Some tests to cover hash_index\\\"\"\n },\n {\n \"msg_contents\": \"On Wed, Sep 28, 2016 at 9:56 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n> something committable will come from it, but with 2 days left it's not\\n> going to happen this CF.\\nAdding a new patch. This one uses generate series instead of INSERT INTO\\nSELECT and fixed comments from Alvaro.\\n\\n-- \\nThanks and Regards\\nMithun C Y\\nEnterpriseDB: http://www.enterprisedb.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, 12 Oct 2016 10:47:43 +0530\",\n \"msg_from\": \"Mithun Cy <mithun.cy@enterprisedb.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: \\\"Some tests to cover hash_index\\\"\"\n },\n {\n \"msg_contents\": \"On Wed, Oct 12, 2016 at 1:17 AM, Mithun Cy <mithun.cy@enterprisedb.com> wrote:\\n> On Wed, Sep 28, 2016 at 9:56 PM, Robert Haas <robertmhaas@gmail.com> wrote:\\n>> something committable will come from it, but with 2 days left it's not\\n>> going to happen this CF.\\n> Adding a new patch. This one uses generate series instead of INSERT INTO\\n> SELECT and fixed comments from Alvaro.\\n\\nCommitted.\\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, 18 Oct 2016 16:00:37 -0400\",\n \"msg_from\": \"Robert Haas <robertmhaas@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: \\\"Some tests to cover hash_index\\\"\"\n }\n]","isConversational":false}}},{"rowIdx":42897,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"Here are two WIP patches to improve the DefElem list processing that is\nused by many utility commands.\n\nOne factors out the duplicate checks, which are currently taking up a\nlot of space with duplicate code. I haven't applied this everywhere\nyet, but the patch shows how much boring code can be saved.\n\nThe other adds a location field to the DefElem node. This allows\nshowing an error pointer if there is a problem in one of the options,\nwhich can be useful for complex commands such as COPY or CREATE USER.\n\nAt the moment, these patches are independent and don't work together,\nbut the second one would become much easier if the first one is accepted.\n\nIf these ideas are acceptable, I'll produce a complete patch series.\n\n-- \nPeter Eisentraut http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\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","msg_date":"Thu, 4 Aug 2016 11:57:06 -0400","msg_from":"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>","msg_from_op":true,"msg_subject":"improved DefElem list processing"},{"msg_contents":"Peter Eisentraut <peter.eisentraut@2ndquadrant.com> writes:\n> Here are two WIP patches to improve the DefElem list processing that is\n> used by many utility commands.\n\n> One factors out the duplicate checks, which are currently taking up a\n> lot of space with duplicate code. I haven't applied this everywhere\n> yet, but the patch shows how much boring code can be saved.\n\n+1 on the general idea, but I wonder if it's a problem that you replaced\nan O(N) check with an O(N^2) check. I don't think there are any commands\nthat would be likely to have so many options that this would become a\nserious issue, but ...\n\n> The other adds a location field to the DefElem node.\n\n+1 for sure, lots of places where that would be a good thing\n(the duplicate check itself, for starters).\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, 04 Aug 2016 14:08:57 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: improved DefElem list processing"},{"msg_contents":"I wrote:\n> Peter Eisentraut <peter.eisentraut@2ndquadrant.com> writes:\n>> The other adds a location field to the DefElem node.\n\n> +1 for sure, lots of places where that would be a good thing\n> (the duplicate check itself, for starters).\n\nForgot to mention: seems like you should have added a location\nargument to makeDefElem.\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, 04 Aug 2016 14:21:01 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: improved DefElem list processing"},{"msg_contents":"On 8/4/16 2:08 PM, Tom Lane wrote:\n> +1 on the general idea, but I wonder if it's a problem that you replaced\n> an O(N) check with an O(N^2) check. I don't think there are any commands\n> that would be likely to have so many options that this would become a\n> serious issue, but ...\n\nI'll run some tests.\n\n-- \nPeter Eisentraut 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":"Fri, 5 Aug 2016 11:24:45 -0400","msg_from":"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>","msg_from_op":true,"msg_subject":"Re: improved DefElem list processing"},{"msg_contents":"On 8/4/16 2:21 PM, Tom Lane wrote:\n> Forgot to mention: seems like you should have added a location\n> argument to makeDefElem.\n\nI was hesitating to do that lest it break extensions or something, but I\nguess we break bigger things than that all the time. I'll change it.\n\n-- \nPeter Eisentraut 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":"Fri, 5 Aug 2016 11:25:34 -0400","msg_from":"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>","msg_from_op":true,"msg_subject":"Re: improved DefElem list processing"},{"msg_contents":"On 8/5/16 11:25 AM, Peter Eisentraut wrote:\n> On 8/4/16 2:21 PM, Tom Lane wrote:\n>> Forgot to mention: seems like you should have added a location\n>> argument to makeDefElem.\n> \n> I was hesitating to do that lest it break extensions or something, but I\n> guess we break bigger things than that all the time. I'll change it.\n\nIn order not to work on two patches that directly conflict with each\nother, I have proceeded with the location patch and postponed the\nduplicate checking patch.\n\nAttached is a biggish patch to review. It adds location information to\nall places DefElems are created in the parser and then adds errposition\ninformation in a lot of places, but surely not all of them. That can be\nimproved over time.\n\nI'm not happy that utils/acl.h has prototypes for aclchk.c, because\nacl.h is included all over the place. Perhaps I should make a\nsrc/include/catalog/aclchk.c to clean that up.\n\nHere are some example commands to try for getting suitable error messages:\n\ncreate collation foo (foo = bar, bar = foo);\ncopy test from stdin (null 'x', null 'x');\ncreate function foo (a int, b int) returns int as $$ select a+b $$\nlanguage sql language sql;\ncreate function foo (a int, b int) returns int as $$ select a+b $$\nlanguage sql volatile stable;\ncreate function foo (a int, b int) returns int as $$ select a+b $$\nlanguage sql with (foo = bar);\ncreate sequence foo minvalue 1 minvalue 2;\ncreate type foo (foo = bar);\ncreate user foo createdb nocreatedb;\nexplain (foo, bar) select 1;\n\n-- \nPeter Eisentraut http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\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":"Thu, 11 Aug 2016 11:32:21 -0400","msg_from":"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>","msg_from_op":true,"msg_subject":"Re: improved DefElem list processing"},{"msg_contents":"Hi\n\n\n2016-08-11 17:32 GMT+02:00 Peter Eisentraut <\npeter.eisentraut@2ndquadrant.com>:\n\n> On 8/5/16 11:25 AM, Peter Eisentraut wrote:\n> > On 8/4/16 2:21 PM, Tom Lane wrote:\n> >> Forgot to mention: seems like you should have added a location\n> >> argument to makeDefElem.\n> >\n> > I was hesitating to do that lest it break extensions or something, but I\n> > guess we break bigger things than that all the time. I'll change it.\n>\n> In order not to work on two patches that directly conflict with each\n> other, I have proceeded with the location patch and postponed the\n> duplicate checking patch.\n>\n> Attached is a biggish patch to review. It adds location information to\n> all places DefElems are created in the parser and then adds errposition\n> information in a lot of places, but surely not all of them. That can be\n> improved over time.\n>\n> I'm not happy that utils/acl.h has prototypes for aclchk.c, because\n> acl.h is included all over the place. Perhaps I should make a\n> src/include/catalog/aclchk.c to clean that up.\n>\n> Here are some example commands to try for getting suitable error messages:\n>\n> create collation foo (foo = bar, bar = foo);\n> copy test from stdin (null 'x', null 'x');\n> create function foo (a int, b int) returns int as $$ select a+b $$\n> language sql language sql;\n> create function foo (a int, b int) returns int as $$ select a+b $$\n> language sql volatile stable;\n> create function foo (a int, b int) returns int as $$ select a+b $$\n> language sql with (foo = bar);\n> create sequence foo minvalue 1 minvalue 2;\n> create type foo (foo = bar);\n> create user foo createdb nocreatedb;\n> explain (foo, bar) select 1;\n>\n> --\n> Peter Eisentraut http://www.2ndQuadrant.com/\n> PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\n>\n>\nI am sending a review of this patch:\n\n1. This patch introduce location in DefElement node, and inject ParserState\nto SQL commands, where ParserState was not used. It allows to show the\nposition of an error. This patch is not small, but almost changes are\ntrivial.\n\n2. There are no problems with patching, compiling, tests - all tests passed.\n\n3. There is not any new functionality, so new tests and new documentation\nis not necessary.\n\nI'll mark this patch as ready for commiter.\n\nRegards\n\nPavel\n\n\n\n\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\nHi2016-08-11 17:32 GMT+02:00 Peter Eisentraut <peter.eisentraut@2ndquadrant.com>:On 8/5/16 11:25 AM, Peter Eisentraut wrote:\n> On 8/4/16 2:21 PM, Tom Lane wrote:\n>> Forgot to mention: seems like you should have added a location\n>> argument to makeDefElem.\n>\n> I was hesitating to do that lest it break extensions or something, but I\n> guess we break bigger things than that all the time. I'll change it.\n\nIn order not to work on two patches that directly conflict with each\nother, I have proceeded with the location patch and postponed the\nduplicate checking patch.\n\nAttached is a biggish patch to review. It adds location information to\nall places DefElems are created in the parser and then adds errposition\ninformation in a lot of places, but surely not all of them. That can be\nimproved over time.\n\nI'm not happy that utils/acl.h has prototypes for aclchk.c, because\nacl.h is included all over the place. Perhaps I should make a\nsrc/include/catalog/aclchk.c to clean that up.\n\nHere are some example commands to try for getting suitable error messages:\n\ncreate collation foo (foo = bar, bar = foo);\ncopy test from stdin (null 'x', null 'x');\ncreate function foo (a int, b int) returns int as $$ select a+b $$\nlanguage sql language sql;\ncreate function foo (a int, b int) returns int as $$ select a+b $$\nlanguage sql volatile stable;\ncreate function foo (a int, b int) returns int as $$ select a+b $$\nlanguage sql with (foo = bar);\ncreate sequence foo minvalue 1 minvalue 2;\ncreate type foo (foo = bar);\ncreate user foo createdb nocreatedb;\nexplain (foo, bar) select 1;\n\n--\nPeter Eisentraut http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\nI am sending a review of this patch:1. This patch introduce location in DefElement node, and inject ParserState to SQL commands, where ParserState was not used. It allows to show the position of an error. This patch is not small, but almost changes are trivial.2. There are no problems with patching, compiling, tests - all tests passed.3. There is not any new functionality, so new tests and new documentation is not necessary.I'll mark this patch as ready for commiter.RegardsPavel \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, 22 Aug 2016 15:41:18 +0200","msg_from":"Pavel Stehule <pavel.stehule@gmail.com>","msg_from_op":false,"msg_subject":"Re: improved DefElem list processing"},{"msg_contents":"On Mon, Aug 22, 2016 at 10:41 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:\n> 1. This patch introduce location in DefElement node, and inject ParserState\n> to SQL commands, where ParserState was not used. It allows to show the\n> position of an error. This patch is not small, but almost changes are\n> trivial.\n>\n> 2. There are no problems with patching, compiling, tests - all tests passed.\n>\n> 3. There is not any new functionality, so new tests and new documentation is\n> not necessary.\n>\n> I'll mark this patch as ready for commiter.\n\nNow that I look at those patches, +1 for both. Particularly the\nredundant-option checks will remove a lot of boring code.\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, 22 Aug 2016 23:25:09 +0900","msg_from":"Michael Paquier <michael.paquier@gmail.com>","msg_from_op":false,"msg_subject":"Re: improved DefElem list processing"},{"msg_contents":"Peter Eisentraut wrote:\n\n> I'm not happy that utils/acl.h has prototypes for aclchk.c, because\n> acl.h is included all over the place. Perhaps I should make a\n> src/include/catalog/aclchk.c to clean that up.\n\nI've been bothered by that too in the past. +1 for the cleanup.\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, 22 Aug 2016 11:28:37 -0300","msg_from":"Alvaro Herrera <alvherre@2ndquadrant.com>","msg_from_op":false,"msg_subject":"Re: improved DefElem list processing"},{"msg_contents":"Peter Eisentraut <peter.eisentraut@2ndquadrant.com> writes:\n> Here are two WIP patches to improve the DefElem list processing that is\n> used by many utility commands.\n\n> One factors out the duplicate checks, which are currently taking up a\n> lot of space with duplicate code. I haven't applied this everywhere\n> yet, but the patch shows how much boring code can be saved.\n\nI'm curious where you are on that? I find myself needing to whack around\nthis processing in CREATE EXTENSION, but I don't want to create a merge\nproblem for you if you're close to committing.\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":"Tue, 06 Sep 2016 19:23:22 -0400","msg_from":"Tom Lane <tgl@sss.pgh.pa.us>","msg_from_op":false,"msg_subject":"Re: improved DefElem list processing"},{"msg_contents":"On 9/6/16 7:23 PM, Tom Lane wrote:\n> I'm curious where you are on that? I find myself needing to whack around\n> this processing in CREATE EXTENSION, but I don't want to create a merge\n> problem for you if you're close to committing.\n\nI have committed what I have for now. Thanks.\n\n-- \nPeter Eisentraut 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, 6 Sep 2016 23:03:13 -0400","msg_from":"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>","msg_from_op":true,"msg_subject":"Re: improved DefElem list processing"},{"msg_contents":"On 8/22/16 10:28 AM, Alvaro Herrera wrote:\n> Peter Eisentraut wrote:\n> \n>> I'm not happy that utils/acl.h has prototypes for aclchk.c, because\n>> acl.h is included all over the place. Perhaps I should make a\n>> src/include/catalog/aclchk.c to clean that up.\n> \n> I've been bothered by that too in the past. +1 for the cleanup.\n\nHere is a patch for that.\n\nIt didn't quite achieve the elegance I was hoping for. Most uses of\nacl.h actually use aclchk.c functions, and the new aclchk.h must include\nacl.h, so basically you end up just changing most includes of acl.h to\naclchk.h while still effectively including acl.h everywhere. But I\nthink having one header file serve two separate .c files is still a\nconfusing pattern that is worth cleaning up.\n\n-- \nPeter Eisentraut http://www.2ndQuadrant.com/\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\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, 10 Sep 2016 07:25:14 -0400","msg_from":"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>","msg_from_op":true,"msg_subject":"Re: improved DefElem list processing"}],"string":"[\n {\n \"msg_contents\": \"Here are two WIP patches to improve the DefElem list processing that is\\nused by many utility commands.\\n\\nOne factors out the duplicate checks, which are currently taking up a\\nlot of space with duplicate code. I haven't applied this everywhere\\nyet, but the patch shows how much boring code can be saved.\\n\\nThe other adds a location field to the DefElem node. This allows\\nshowing an error pointer if there is a problem in one of the options,\\nwhich can be useful for complex commands such as COPY or CREATE USER.\\n\\nAt the moment, these patches are independent and don't work together,\\nbut the second one would become much easier if the first one is accepted.\\n\\nIf these ideas are acceptable, I'll produce a complete patch series.\\n\\n-- \\nPeter Eisentraut http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\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\": \"Thu, 4 Aug 2016 11:57:06 -0400\",\n \"msg_from\": \"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"improved DefElem list processing\"\n },\n {\n \"msg_contents\": \"Peter Eisentraut <peter.eisentraut@2ndquadrant.com> writes:\\n> Here are two WIP patches to improve the DefElem list processing that is\\n> used by many utility commands.\\n\\n> One factors out the duplicate checks, which are currently taking up a\\n> lot of space with duplicate code. I haven't applied this everywhere\\n> yet, but the patch shows how much boring code can be saved.\\n\\n+1 on the general idea, but I wonder if it's a problem that you replaced\\nan O(N) check with an O(N^2) check. I don't think there are any commands\\nthat would be likely to have so many options that this would become a\\nserious issue, but ...\\n\\n> The other adds a location field to the DefElem node.\\n\\n+1 for sure, lots of places where that would be a good thing\\n(the duplicate check itself, for starters).\\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, 04 Aug 2016 14:08:57 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: improved DefElem list processing\"\n },\n {\n \"msg_contents\": \"I wrote:\\n> Peter Eisentraut <peter.eisentraut@2ndquadrant.com> writes:\\n>> The other adds a location field to the DefElem node.\\n\\n> +1 for sure, lots of places where that would be a good thing\\n> (the duplicate check itself, for starters).\\n\\nForgot to mention: seems like you should have added a location\\nargument to makeDefElem.\\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, 04 Aug 2016 14:21:01 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: improved DefElem list processing\"\n },\n {\n \"msg_contents\": \"On 8/4/16 2:08 PM, Tom Lane wrote:\\n> +1 on the general idea, but I wonder if it's a problem that you replaced\\n> an O(N) check with an O(N^2) check. I don't think there are any commands\\n> that would be likely to have so many options that this would become a\\n> serious issue, but ...\\n\\nI'll run some tests.\\n\\n-- \\nPeter Eisentraut 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\": \"Fri, 5 Aug 2016 11:24:45 -0400\",\n \"msg_from\": \"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: improved DefElem list processing\"\n },\n {\n \"msg_contents\": \"On 8/4/16 2:21 PM, Tom Lane wrote:\\n> Forgot to mention: seems like you should have added a location\\n> argument to makeDefElem.\\n\\nI was hesitating to do that lest it break extensions or something, but I\\nguess we break bigger things than that all the time. I'll change it.\\n\\n-- \\nPeter Eisentraut 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\": \"Fri, 5 Aug 2016 11:25:34 -0400\",\n \"msg_from\": \"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: improved DefElem list processing\"\n },\n {\n \"msg_contents\": \"On 8/5/16 11:25 AM, Peter Eisentraut wrote:\\n> On 8/4/16 2:21 PM, Tom Lane wrote:\\n>> Forgot to mention: seems like you should have added a location\\n>> argument to makeDefElem.\\n> \\n> I was hesitating to do that lest it break extensions or something, but I\\n> guess we break bigger things than that all the time. I'll change it.\\n\\nIn order not to work on two patches that directly conflict with each\\nother, I have proceeded with the location patch and postponed the\\nduplicate checking patch.\\n\\nAttached is a biggish patch to review. It adds location information to\\nall places DefElems are created in the parser and then adds errposition\\ninformation in a lot of places, but surely not all of them. That can be\\nimproved over time.\\n\\nI'm not happy that utils/acl.h has prototypes for aclchk.c, because\\nacl.h is included all over the place. Perhaps I should make a\\nsrc/include/catalog/aclchk.c to clean that up.\\n\\nHere are some example commands to try for getting suitable error messages:\\n\\ncreate collation foo (foo = bar, bar = foo);\\ncopy test from stdin (null 'x', null 'x');\\ncreate function foo (a int, b int) returns int as $$ select a+b $$\\nlanguage sql language sql;\\ncreate function foo (a int, b int) returns int as $$ select a+b $$\\nlanguage sql volatile stable;\\ncreate function foo (a int, b int) returns int as $$ select a+b $$\\nlanguage sql with (foo = bar);\\ncreate sequence foo minvalue 1 minvalue 2;\\ncreate type foo (foo = bar);\\ncreate user foo createdb nocreatedb;\\nexplain (foo, bar) select 1;\\n\\n-- \\nPeter Eisentraut http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\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\": \"Thu, 11 Aug 2016 11:32:21 -0400\",\n \"msg_from\": \"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: improved DefElem list processing\"\n },\n {\n \"msg_contents\": \"Hi\\n\\n\\n2016-08-11 17:32 GMT+02:00 Peter Eisentraut <\\npeter.eisentraut@2ndquadrant.com>:\\n\\n> On 8/5/16 11:25 AM, Peter Eisentraut wrote:\\n> > On 8/4/16 2:21 PM, Tom Lane wrote:\\n> >> Forgot to mention: seems like you should have added a location\\n> >> argument to makeDefElem.\\n> >\\n> > I was hesitating to do that lest it break extensions or something, but I\\n> > guess we break bigger things than that all the time. I'll change it.\\n>\\n> In order not to work on two patches that directly conflict with each\\n> other, I have proceeded with the location patch and postponed the\\n> duplicate checking patch.\\n>\\n> Attached is a biggish patch to review. It adds location information to\\n> all places DefElems are created in the parser and then adds errposition\\n> information in a lot of places, but surely not all of them. That can be\\n> improved over time.\\n>\\n> I'm not happy that utils/acl.h has prototypes for aclchk.c, because\\n> acl.h is included all over the place. Perhaps I should make a\\n> src/include/catalog/aclchk.c to clean that up.\\n>\\n> Here are some example commands to try for getting suitable error messages:\\n>\\n> create collation foo (foo = bar, bar = foo);\\n> copy test from stdin (null 'x', null 'x');\\n> create function foo (a int, b int) returns int as $$ select a+b $$\\n> language sql language sql;\\n> create function foo (a int, b int) returns int as $$ select a+b $$\\n> language sql volatile stable;\\n> create function foo (a int, b int) returns int as $$ select a+b $$\\n> language sql with (foo = bar);\\n> create sequence foo minvalue 1 minvalue 2;\\n> create type foo (foo = bar);\\n> create user foo createdb nocreatedb;\\n> explain (foo, bar) select 1;\\n>\\n> --\\n> Peter Eisentraut http://www.2ndQuadrant.com/\\n> PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\n>\\n>\\nI am sending a review of this patch:\\n\\n1. This patch introduce location in DefElement node, and inject ParserState\\nto SQL commands, where ParserState was not used. It allows to show the\\nposition of an error. This patch is not small, but almost changes are\\ntrivial.\\n\\n2. There are no problems with patching, compiling, tests - all tests passed.\\n\\n3. There is not any new functionality, so new tests and new documentation\\nis not necessary.\\n\\nI'll mark this patch as ready for commiter.\\n\\nRegards\\n\\nPavel\\n\\n\\n\\n\\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\\nHi2016-08-11 17:32 GMT+02:00 Peter Eisentraut <peter.eisentraut@2ndquadrant.com>:On 8/5/16 11:25 AM, Peter Eisentraut wrote:\\n> On 8/4/16 2:21 PM, Tom Lane wrote:\\n>> Forgot to mention: seems like you should have added a location\\n>> argument to makeDefElem.\\n>\\n> I was hesitating to do that lest it break extensions or something, but I\\n> guess we break bigger things than that all the time. I'll change it.\\n\\nIn order not to work on two patches that directly conflict with each\\nother, I have proceeded with the location patch and postponed the\\nduplicate checking patch.\\n\\nAttached is a biggish patch to review. It adds location information to\\nall places DefElems are created in the parser and then adds errposition\\ninformation in a lot of places, but surely not all of them. That can be\\nimproved over time.\\n\\nI'm not happy that utils/acl.h has prototypes for aclchk.c, because\\nacl.h is included all over the place. Perhaps I should make a\\nsrc/include/catalog/aclchk.c to clean that up.\\n\\nHere are some example commands to try for getting suitable error messages:\\n\\ncreate collation foo (foo = bar, bar = foo);\\ncopy test from stdin (null 'x', null 'x');\\ncreate function foo (a int, b int) returns int as $$ select a+b $$\\nlanguage sql language sql;\\ncreate function foo (a int, b int) returns int as $$ select a+b $$\\nlanguage sql volatile stable;\\ncreate function foo (a int, b int) returns int as $$ select a+b $$\\nlanguage sql with (foo = bar);\\ncreate sequence foo minvalue 1 minvalue 2;\\ncreate type foo (foo = bar);\\ncreate user foo createdb nocreatedb;\\nexplain (foo, bar) select 1;\\n\\n--\\nPeter Eisentraut http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\nI am sending a review of this patch:1. This patch introduce location in DefElement node, and inject ParserState to SQL commands, where ParserState was not used. It allows to show the position of an error. This patch is not small, but almost changes are trivial.2. There are no problems with patching, compiling, tests - all tests passed.3. There is not any new functionality, so new tests and new documentation is not necessary.I'll mark this patch as ready for commiter.RegardsPavel \\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, 22 Aug 2016 15:41:18 +0200\",\n \"msg_from\": \"Pavel Stehule <pavel.stehule@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: improved DefElem list processing\"\n },\n {\n \"msg_contents\": \"On Mon, Aug 22, 2016 at 10:41 PM, Pavel Stehule <pavel.stehule@gmail.com> wrote:\\n> 1. This patch introduce location in DefElement node, and inject ParserState\\n> to SQL commands, where ParserState was not used. It allows to show the\\n> position of an error. This patch is not small, but almost changes are\\n> trivial.\\n>\\n> 2. There are no problems with patching, compiling, tests - all tests passed.\\n>\\n> 3. There is not any new functionality, so new tests and new documentation is\\n> not necessary.\\n>\\n> I'll mark this patch as ready for commiter.\\n\\nNow that I look at those patches, +1 for both. Particularly the\\nredundant-option checks will remove a lot of boring code.\\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, 22 Aug 2016 23:25:09 +0900\",\n \"msg_from\": \"Michael Paquier <michael.paquier@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: improved DefElem list processing\"\n },\n {\n \"msg_contents\": \"Peter Eisentraut wrote:\\n\\n> I'm not happy that utils/acl.h has prototypes for aclchk.c, because\\n> acl.h is included all over the place. Perhaps I should make a\\n> src/include/catalog/aclchk.c to clean that up.\\n\\nI've been bothered by that too in the past. +1 for the cleanup.\\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, 22 Aug 2016 11:28:37 -0300\",\n \"msg_from\": \"Alvaro Herrera <alvherre@2ndquadrant.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: improved DefElem list processing\"\n },\n {\n \"msg_contents\": \"Peter Eisentraut <peter.eisentraut@2ndquadrant.com> writes:\\n> Here are two WIP patches to improve the DefElem list processing that is\\n> used by many utility commands.\\n\\n> One factors out the duplicate checks, which are currently taking up a\\n> lot of space with duplicate code. I haven't applied this everywhere\\n> yet, but the patch shows how much boring code can be saved.\\n\\nI'm curious where you are on that? I find myself needing to whack around\\nthis processing in CREATE EXTENSION, but I don't want to create a merge\\nproblem for you if you're close to committing.\\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\": \"Tue, 06 Sep 2016 19:23:22 -0400\",\n \"msg_from\": \"Tom Lane <tgl@sss.pgh.pa.us>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: improved DefElem list processing\"\n },\n {\n \"msg_contents\": \"On 9/6/16 7:23 PM, Tom Lane wrote:\\n> I'm curious where you are on that? I find myself needing to whack around\\n> this processing in CREATE EXTENSION, but I don't want to create a merge\\n> problem for you if you're close to committing.\\n\\nI have committed what I have for now. Thanks.\\n\\n-- \\nPeter Eisentraut 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, 6 Sep 2016 23:03:13 -0400\",\n \"msg_from\": \"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: improved DefElem list processing\"\n },\n {\n \"msg_contents\": \"On 8/22/16 10:28 AM, Alvaro Herrera wrote:\\n> Peter Eisentraut wrote:\\n> \\n>> I'm not happy that utils/acl.h has prototypes for aclchk.c, because\\n>> acl.h is included all over the place. Perhaps I should make a\\n>> src/include/catalog/aclchk.c to clean that up.\\n> \\n> I've been bothered by that too in the past. +1 for the cleanup.\\n\\nHere is a patch for that.\\n\\nIt didn't quite achieve the elegance I was hoping for. Most uses of\\nacl.h actually use aclchk.c functions, and the new aclchk.h must include\\nacl.h, so basically you end up just changing most includes of acl.h to\\naclchk.h while still effectively including acl.h everywhere. But I\\nthink having one header file serve two separate .c files is still a\\nconfusing pattern that is worth cleaning up.\\n\\n-- \\nPeter Eisentraut http://www.2ndQuadrant.com/\\nPostgreSQL Development, 24x7 Support, Remote DBA, Training & Services\\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\": \"Sat, 10 Sep 2016 07:25:14 -0400\",\n \"msg_from\": \"Peter Eisentraut <peter.eisentraut@2ndquadrant.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: improved DefElem list processing\"\n }\n]","isConversational":false}}},{"rowIdx":42898,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"\"\\echo\" has \"\\qecho\" - I'm basically looking for a \"\\qprint\"\n\n\"\\write\" doesn't apply\n\nThe following doesn't work either...\n\n#bash (stock Ubuntu 14.04)\npsql --set=query_in_var='SELECT version();' > /dev/null <<'SQL'\n\\o /tmp/psql-test.txt\n\\set ECHO queries\n--still ends up on stdout, hence the redirect to /dev/null to avoid it\nshowing on screen along with the cat output below\n:query_in_var\n\\o\nSQL\ncat /tmp/psql-test.txt\n\nCan anyone offer a reason not to add \"\\qprint\"?\n\nDavid J.\n\n\"\\echo\" has \"\\qecho\" - I'm basically looking for a \"\\qprint\"\"\\write\" doesn't applyThe following doesn't work either...#bash (stock Ubuntu 14.04)psql --set=query_in_var='SELECT version();' > /dev/null <<'SQL'\\o /tmp/psql-test.txt\\set ECHO queries--still ends up on stdout, hence the redirect to /dev/null to avoid it showing on screen along with the cat output below :query_in_var\\oSQLcat /tmp/psql-test.txtCan anyone offer a reason not to add \"\\qprint\"?David J.","msg_date":"Thu, 4 Aug 2016 13:42:16 -0400","msg_from":"\"David G. Johnston\" <david.g.johnston@gmail.com>","msg_from_op":true,"msg_subject":"psql: Missing option to print current buffer to current output\n channel (i.e., \\qprint)"}],"string":"[\n {\n \"msg_contents\": \"\\\"\\\\echo\\\" has \\\"\\\\qecho\\\" - I'm basically looking for a \\\"\\\\qprint\\\"\\n\\n\\\"\\\\write\\\" doesn't apply\\n\\nThe following doesn't work either...\\n\\n#bash (stock Ubuntu 14.04)\\npsql --set=query_in_var='SELECT version();' > /dev/null <<'SQL'\\n\\\\o /tmp/psql-test.txt\\n\\\\set ECHO queries\\n--still ends up on stdout, hence the redirect to /dev/null to avoid it\\nshowing on screen along with the cat output below\\n:query_in_var\\n\\\\o\\nSQL\\ncat /tmp/psql-test.txt\\n\\nCan anyone offer a reason not to add \\\"\\\\qprint\\\"?\\n\\nDavid J.\\n\\n\\\"\\\\echo\\\" has \\\"\\\\qecho\\\" - I'm basically looking for a \\\"\\\\qprint\\\"\\\"\\\\write\\\" doesn't applyThe following doesn't work either...#bash (stock Ubuntu 14.04)psql --set=query_in_var='SELECT version();' > /dev/null <<'SQL'\\\\o /tmp/psql-test.txt\\\\set ECHO queries--still ends up on stdout, hence the redirect to /dev/null to avoid it showing on screen along with the cat output below :query_in_var\\\\oSQLcat /tmp/psql-test.txtCan anyone offer a reason not to add \\\"\\\\qprint\\\"?David J.\",\n \"msg_date\": \"Thu, 4 Aug 2016 13:42:16 -0400\",\n \"msg_from\": \"\\\"David G. Johnston\\\" <david.g.johnston@gmail.com>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"psql: Missing option to print current buffer to current output\\n channel (i.e., \\\\qprint)\"\n }\n]","isConversational":false}}},{"rowIdx":42899,"cells":{"threads":{"kind":"list like","value":[{"msg_contents":"I'm trying to run pgbench on a moderately beefy machine (4-core 3.4GHz\nwith 32G of ram and md mirrored spinning rust drives) at scale 300\nwith 32 clients with duration of 15min. I'm getting TPS numbers\nbetween 60-150 which seems surprisingly low to me and also to several\npeople on IRC.\n\nNow pg_test_fsync does seem to indicate that's not an unreasonable\ncommit rate if there was very little commit grouping going on:\n\nCompare file sync methods using one 8kB write:\n open_datasync 100.781 ops/sec 9922 usecs/op\n fdatasync 71.088 ops/sec 14067 usecs/op\n\nCompare file sync methods using two 8kB writes:\n open_datasync 50.286 ops/sec 19886 usecs/op\n fdatasync 80.349 ops/sec 12446 usecs/op\n\nAnd iostat does seem to indicate the drives are ~ 80% utilized with\nhigh write await times So maybe this is just what the system is\ncapable of with synchronous_commit?\n\nIs anyone really familiar with pg_bench on similar hardware? Are these\nnumbers reasonable? Any suggestion for how to run it to get the most\nrealistic measure of Postgres on this machine?\n\nstarting vacuum...end.\ntransaction type: <builtin: TPC-B (sort of)>\nscaling factor: 300\nquery mode: simple\nnumber of clients: 32\nnumber of threads: 4\nduration: 900 s\nnumber of transactions actually processed: 109424\nlatency average: 263.196 ms\ntps = 121.464536 (including connections establishing)\ntps = 121.464824 (excluding connections establishing)\nscript statistics:\n - statement latencies in milliseconds:\n 0.002 \\set aid random(1, 100000 * :scale)\n 0.001 \\set bid random(1, 1 * :scale)\n 0.001 \\set tid random(1, 10 * :scale)\n 0.001 \\set delta random(-5000, 5000)\n 0.229 BEGIN;\n 12.589 UPDATE pgbench_accounts SET abalance = abalance +\n:delta WHERE aid = :aid;\n 0.280 SELECT abalance FROM pgbench_accounts WHERE aid = :aid;\n 1.442 UPDATE pgbench_tellers SET tbalance = tbalance +\n:delta WHERE tid = :tid;\n 12.435 UPDATE pgbench_branches SET bbalance = bbalance +\n:delta WHERE bid = :bid;\n 0.222 INSERT INTO pgbench_history (tid, bid, aid, delta,\nmtime) VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);\n 237.623 END;\n\nAnd the iostat for the period the pg_bench is running:\n\navg-cpu: %user %nice %system %iowait %steal %idle\n 1,31 0,00 0,43 20,48 0,00 77,78\n\nDevice: rrqm/s wrqm/s r/s w/s rkB/s wkB/s\navgrq-sz avgqu-sz await r_await w_await svctm %util\nsdb 0,00 2,47 14,31 181,13 175,96 2897,77\n31,45 80,85 413,63 67,55 440,97 4,16 81,35\nsda 0,01 2,47 23,77 181,13 292,04 2897,77\n31,14 66,72 325,59 51,08 361,61 3,92 80,40\nmd0 0,00 0,00 0,05 0,00 0,20 0,00\n8,00 0,00 0,00 0,00 0,00 0,00 0,00\nmd1 0,00 0,00 0,00 0,00 0,00 0,00\n0,00 0,00 0,00 0,00 0,00 0,00 0,00\nmd2 0,00 0,00 38,04 182,79 467,79 2895,73\n30,46 0,00 0,00 0,00 0,00 0,00 0,00\nmd3 0,00 0,00 0,00 0,01 0,00 0,04\n8,00 0,00 0,00 0,00 0,00 0,00 0,00\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, 4 Aug 2016 18:48:31 +0100","msg_from":"Greg Stark <stark@mit.edu>","msg_from_op":true,"msg_subject":"Pgbench performance tuning?"},{"msg_contents":"On 2016-08-04 18:48:31 +0100, Greg Stark wrote:\n> I'm trying to run pgbench on a moderately beefy machine (4-core 3.4GHz\n> with 32G of ram and md mirrored spinning rust drives) at scale 300\n> with 32 clients with duration of 15min. I'm getting TPS numbers\n> between 60-150 which seems surprisingly low to me and also to several\n> people on IRC.\n\nWhat's the config? Version? What activity does pidstat -d -l indicate?\nHow much WAL was generated?\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":"Thu, 4 Aug 2016 10:53:03 -0700","msg_from":"Andres Freund <andres@anarazel.de>","msg_from_op":false,"msg_subject":"Re: Pgbench performance tuning?"},{"msg_contents":"On Thu, Aug 4, 2016 at 6:53 PM, Andres Freund <andres@anarazel.de> wrote:\n> What's the config? Version? What activity does pidstat -d -l indicate?\n> How much WAL was generated?\n\nI know the specifics matter but I was also trying to avoid dumping too\nmuch into the email.\n\nThe shared buffers is set to 16384 (128MB). Otherwise it's a default\nconfig (For 9.4 and before I set checkpoint_segments to 32 as well).\n\nNever seen pidstat before but pidstat -d looks like it prints very\nsimilar output to the iostat output I was gathering already. There's\nnothing else running on the machine.\n\nI would have to rerun the benchmarks to measure the WAL output. Since\nthere's no replication and the database shut down cleanly it looks\nlike it recycled all the log files proactively and the last checkpoint\nis in the earliest numbered xlog file.\n\nI'll add checking the xlog position before and after pg_bench to the\nscript. I also wanted to use run the database under a binary calling\ngetrusage to report RUSAGE_CHILDREN for the database. It looks like\nthere's no stock program to do this but it shouldn't be hard to hack\none up.\n\n-- \ngreg\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, 4 Aug 2016 19:15:43 +0100","msg_from":"Greg Stark <stark@mit.edu>","msg_from_op":true,"msg_subject":"Re: Pgbench performance tuning?"},{"msg_contents":"On 2016-08-04 19:15:43 +0100, Greg Stark wrote:\n> On Thu, Aug 4, 2016 at 6:53 PM, Andres Freund <andres@anarazel.de> wrote:\n> > What's the config? Version? What activity does pidstat -d -l indicate?\n> > How much WAL was generated?\n> \n> I know the specifics matter but I was also trying to avoid dumping too\n> much into the email.\n> \n> The shared buffers is set to 16384 (128MB). Otherwise it's a default\n> config (For 9.4 and before I set checkpoint_segments to 32 as well).\n\nWell, with 128MB I don't find that a very surprising result. You're\ngoing to push data out to disk constantly. Given the averaged random\naccess pattern of pgbench that's not really something that interesting.\n\n\n> Never seen pidstat before but pidstat -d looks like it prints very\n> similar output to the iostat output I was gathering already. There's\n> nothing else running on the machine.\n\nThe question is which backends are doing the IO.\n\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":"Thu, 4 Aug 2016 11:20:37 -0700","msg_from":"Andres Freund <andres@anarazel.de>","msg_from_op":false,"msg_subject":"Re: Pgbench performance tuning?"},{"msg_contents":"On Thu, Aug 4, 2016 at 10:48 AM, Greg Stark <stark@mit.edu> wrote:\n> I'm trying to run pgbench on a moderately beefy machine (4-core 3.4GHz\n> with 32G of ram and md mirrored spinning rust drives) at scale 300\n> with 32 clients with duration of 15min. I'm getting TPS numbers\n> between 60-150 which seems surprisingly low to me and also to several\n> people on IRC.\n\nI am assuming \"md mirrored\" means you have two drives, so there is no\nstriping. What is their RPM?\n\nYour IO system is inadequate and I'm only slightly surprised at the low TPS.\n\n> Now pg_test_fsync does seem to indicate that's not an unreasonable\n> commit rate if there was very little commit grouping going on:\n>\n> Compare file sync methods using one 8kB write:\n> open_datasync 100.781 ops/sec 9922 usecs/op\n> fdatasync 71.088 ops/sec 14067 usecs/op\n>\n> Compare file sync methods using two 8kB writes:\n> open_datasync 50.286 ops/sec 19886 usecs/op\n> fdatasync 80.349 ops/sec 12446 usecs/op\n>\n> And iostat does seem to indicate the drives are ~ 80% utilized with\n> high write await times So maybe this is just what the system is\n> capable of with synchronous_commit?\n\nAs an experiment, turn off synchrounous_commit and see what happens.\n\nMostly likely you are getting adequate commit grouping behavior, but\nthat doesn't apply to the table data. Each transaction dirties some\nrandom page in the 3.9GB pgbench_accounts table, and there is no\neffective grouping of those writes. That data isn't written\nsynchronously, but in the steady state it doesn't really matter\nbecause at some point the write rate has to equilibrate with the\ndirtying rate. If you can't make the disks faster then the TPS has to\ndrop to meet them. The most likely mechanism for this to happen is\nthat the disks are so harried trying to keep up with the dirty data\neviction, that they can't service the sync calls from the commits in a\ntimely matter. But if you took the sync calls out, the bottleneck\nwould likely just move somewhere else with only modest overall\nimprovement.\n\nThe way to tune it would be to make shared_buffers large enough that\nall of pgbench_accounts fits in it, and increase checkpoint_segments\nand checkpoint_timeout as much as you can afford, and increase\ncheckpoint_completion_target.\n\nCheers,\n\nJeff\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, 4 Aug 2016 14:19:24 -0700","msg_from":"Jeff Janes <jeff.janes@gmail.com>","msg_from_op":false,"msg_subject":"Re: Pgbench performance tuning?"}],"string":"[\n {\n \"msg_contents\": \"I'm trying to run pgbench on a moderately beefy machine (4-core 3.4GHz\\nwith 32G of ram and md mirrored spinning rust drives) at scale 300\\nwith 32 clients with duration of 15min. I'm getting TPS numbers\\nbetween 60-150 which seems surprisingly low to me and also to several\\npeople on IRC.\\n\\nNow pg_test_fsync does seem to indicate that's not an unreasonable\\ncommit rate if there was very little commit grouping going on:\\n\\nCompare file sync methods using one 8kB write:\\n open_datasync 100.781 ops/sec 9922 usecs/op\\n fdatasync 71.088 ops/sec 14067 usecs/op\\n\\nCompare file sync methods using two 8kB writes:\\n open_datasync 50.286 ops/sec 19886 usecs/op\\n fdatasync 80.349 ops/sec 12446 usecs/op\\n\\nAnd iostat does seem to indicate the drives are ~ 80% utilized with\\nhigh write await times So maybe this is just what the system is\\ncapable of with synchronous_commit?\\n\\nIs anyone really familiar with pg_bench on similar hardware? Are these\\nnumbers reasonable? Any suggestion for how to run it to get the most\\nrealistic measure of Postgres on this machine?\\n\\nstarting vacuum...end.\\ntransaction type: <builtin: TPC-B (sort of)>\\nscaling factor: 300\\nquery mode: simple\\nnumber of clients: 32\\nnumber of threads: 4\\nduration: 900 s\\nnumber of transactions actually processed: 109424\\nlatency average: 263.196 ms\\ntps = 121.464536 (including connections establishing)\\ntps = 121.464824 (excluding connections establishing)\\nscript statistics:\\n - statement latencies in milliseconds:\\n 0.002 \\\\set aid random(1, 100000 * :scale)\\n 0.001 \\\\set bid random(1, 1 * :scale)\\n 0.001 \\\\set tid random(1, 10 * :scale)\\n 0.001 \\\\set delta random(-5000, 5000)\\n 0.229 BEGIN;\\n 12.589 UPDATE pgbench_accounts SET abalance = abalance +\\n:delta WHERE aid = :aid;\\n 0.280 SELECT abalance FROM pgbench_accounts WHERE aid = :aid;\\n 1.442 UPDATE pgbench_tellers SET tbalance = tbalance +\\n:delta WHERE tid = :tid;\\n 12.435 UPDATE pgbench_branches SET bbalance = bbalance +\\n:delta WHERE bid = :bid;\\n 0.222 INSERT INTO pgbench_history (tid, bid, aid, delta,\\nmtime) VALUES (:tid, :bid, :aid, :delta, CURRENT_TIMESTAMP);\\n 237.623 END;\\n\\nAnd the iostat for the period the pg_bench is running:\\n\\navg-cpu: %user %nice %system %iowait %steal %idle\\n 1,31 0,00 0,43 20,48 0,00 77,78\\n\\nDevice: rrqm/s wrqm/s r/s w/s rkB/s wkB/s\\navgrq-sz avgqu-sz await r_await w_await svctm %util\\nsdb 0,00 2,47 14,31 181,13 175,96 2897,77\\n31,45 80,85 413,63 67,55 440,97 4,16 81,35\\nsda 0,01 2,47 23,77 181,13 292,04 2897,77\\n31,14 66,72 325,59 51,08 361,61 3,92 80,40\\nmd0 0,00 0,00 0,05 0,00 0,20 0,00\\n8,00 0,00 0,00 0,00 0,00 0,00 0,00\\nmd1 0,00 0,00 0,00 0,00 0,00 0,00\\n0,00 0,00 0,00 0,00 0,00 0,00 0,00\\nmd2 0,00 0,00 38,04 182,79 467,79 2895,73\\n30,46 0,00 0,00 0,00 0,00 0,00 0,00\\nmd3 0,00 0,00 0,00 0,01 0,00 0,04\\n8,00 0,00 0,00 0,00 0,00 0,00 0,00\\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, 4 Aug 2016 18:48:31 +0100\",\n \"msg_from\": \"Greg Stark <stark@mit.edu>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Pgbench performance tuning?\"\n },\n {\n \"msg_contents\": \"On 2016-08-04 18:48:31 +0100, Greg Stark wrote:\\n> I'm trying to run pgbench on a moderately beefy machine (4-core 3.4GHz\\n> with 32G of ram and md mirrored spinning rust drives) at scale 300\\n> with 32 clients with duration of 15min. I'm getting TPS numbers\\n> between 60-150 which seems surprisingly low to me and also to several\\n> people on IRC.\\n\\nWhat's the config? Version? What activity does pidstat -d -l indicate?\\nHow much WAL was generated?\\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\": \"Thu, 4 Aug 2016 10:53:03 -0700\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Pgbench performance tuning?\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 6:53 PM, Andres Freund <andres@anarazel.de> wrote:\\n> What's the config? Version? What activity does pidstat -d -l indicate?\\n> How much WAL was generated?\\n\\nI know the specifics matter but I was also trying to avoid dumping too\\nmuch into the email.\\n\\nThe shared buffers is set to 16384 (128MB). Otherwise it's a default\\nconfig (For 9.4 and before I set checkpoint_segments to 32 as well).\\n\\nNever seen pidstat before but pidstat -d looks like it prints very\\nsimilar output to the iostat output I was gathering already. There's\\nnothing else running on the machine.\\n\\nI would have to rerun the benchmarks to measure the WAL output. Since\\nthere's no replication and the database shut down cleanly it looks\\nlike it recycled all the log files proactively and the last checkpoint\\nis in the earliest numbered xlog file.\\n\\nI'll add checking the xlog position before and after pg_bench to the\\nscript. I also wanted to use run the database under a binary calling\\ngetrusage to report RUSAGE_CHILDREN for the database. It looks like\\nthere's no stock program to do this but it shouldn't be hard to hack\\none up.\\n\\n-- \\ngreg\\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, 4 Aug 2016 19:15:43 +0100\",\n \"msg_from\": \"Greg Stark <stark@mit.edu>\",\n \"msg_from_op\": true,\n \"msg_subject\": \"Re: Pgbench performance tuning?\"\n },\n {\n \"msg_contents\": \"On 2016-08-04 19:15:43 +0100, Greg Stark wrote:\\n> On Thu, Aug 4, 2016 at 6:53 PM, Andres Freund <andres@anarazel.de> wrote:\\n> > What's the config? Version? What activity does pidstat -d -l indicate?\\n> > How much WAL was generated?\\n> \\n> I know the specifics matter but I was also trying to avoid dumping too\\n> much into the email.\\n> \\n> The shared buffers is set to 16384 (128MB). Otherwise it's a default\\n> config (For 9.4 and before I set checkpoint_segments to 32 as well).\\n\\nWell, with 128MB I don't find that a very surprising result. You're\\ngoing to push data out to disk constantly. Given the averaged random\\naccess pattern of pgbench that's not really something that interesting.\\n\\n\\n> Never seen pidstat before but pidstat -d looks like it prints very\\n> similar output to the iostat output I was gathering already. There's\\n> nothing else running on the machine.\\n\\nThe question is which backends are doing the IO.\\n\\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\": \"Thu, 4 Aug 2016 11:20:37 -0700\",\n \"msg_from\": \"Andres Freund <andres@anarazel.de>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Pgbench performance tuning?\"\n },\n {\n \"msg_contents\": \"On Thu, Aug 4, 2016 at 10:48 AM, Greg Stark <stark@mit.edu> wrote:\\n> I'm trying to run pgbench on a moderately beefy machine (4-core 3.4GHz\\n> with 32G of ram and md mirrored spinning rust drives) at scale 300\\n> with 32 clients with duration of 15min. I'm getting TPS numbers\\n> between 60-150 which seems surprisingly low to me and also to several\\n> people on IRC.\\n\\nI am assuming \\\"md mirrored\\\" means you have two drives, so there is no\\nstriping. What is their RPM?\\n\\nYour IO system is inadequate and I'm only slightly surprised at the low TPS.\\n\\n> Now pg_test_fsync does seem to indicate that's not an unreasonable\\n> commit rate if there was very little commit grouping going on:\\n>\\n> Compare file sync methods using one 8kB write:\\n> open_datasync 100.781 ops/sec 9922 usecs/op\\n> fdatasync 71.088 ops/sec 14067 usecs/op\\n>\\n> Compare file sync methods using two 8kB writes:\\n> open_datasync 50.286 ops/sec 19886 usecs/op\\n> fdatasync 80.349 ops/sec 12446 usecs/op\\n>\\n> And iostat does seem to indicate the drives are ~ 80% utilized with\\n> high write await times So maybe this is just what the system is\\n> capable of with synchronous_commit?\\n\\nAs an experiment, turn off synchrounous_commit and see what happens.\\n\\nMostly likely you are getting adequate commit grouping behavior, but\\nthat doesn't apply to the table data. Each transaction dirties some\\nrandom page in the 3.9GB pgbench_accounts table, and there is no\\neffective grouping of those writes. That data isn't written\\nsynchronously, but in the steady state it doesn't really matter\\nbecause at some point the write rate has to equilibrate with the\\ndirtying rate. If you can't make the disks faster then the TPS has to\\ndrop to meet them. The most likely mechanism for this to happen is\\nthat the disks are so harried trying to keep up with the dirty data\\neviction, that they can't service the sync calls from the commits in a\\ntimely matter. But if you took the sync calls out, the bottleneck\\nwould likely just move somewhere else with only modest overall\\nimprovement.\\n\\nThe way to tune it would be to make shared_buffers large enough that\\nall of pgbench_accounts fits in it, and increase checkpoint_segments\\nand checkpoint_timeout as much as you can afford, and increase\\ncheckpoint_completion_target.\\n\\nCheers,\\n\\nJeff\\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, 4 Aug 2016 14:19:24 -0700\",\n \"msg_from\": \"Jeff Janes <jeff.janes@gmail.com>\",\n \"msg_from_op\": false,\n \"msg_subject\": \"Re: Pgbench performance tuning?\"\n }\n]","isConversational":false}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":428,"numItemsPerPage":100,"numTotalItems":58371,"offset":42800,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTQ3NTcxNiwianRpIjoiZjY2NWYwZDgtYzBiMS00MDFlLThlZWYtMTIwYzY0MGQ4ZTEzIiwic3ViIjoiL2RhdGFzZXRzL3dhbnNoZW5sL3Bnc3FsLWhhY2tlcnMiLCJleHAiOjE3ODU0NzkzMTYsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.3zLyJFt21qWUQKo5RlK7fqM380UXiRX_9QW72n3tpiUwSUorDsoXhgsjqRo9V1GJ4vqRGSC5Gsx0i47ZWUEgCg","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": "While researching a pgsql-general question, I noticed that commit\n73c986adde5d73a5e2555da9b5c8facedb146dcd added several new fields\nto pg_control without bothering to touch PG_CONTROL_VERSION. Thus,\nPG_CONTROL_VERSION is still \"942\" even though the file contents\nare not at all compatib... |
[
{
"msg_contents": "Hi,\n\nWhile validating my patch for http://archives.postgresql.org/message-id/20160714060607.klwgq2qr7egt3zrr%40alap3.anarazel.de\nI noticed that the standby's infomask still had HEAP_XMAX_INVALID set\nafter replaying a XLOG_HEAP_LOCK record.\n\nThat's bad, but not really commonly fatal, bec... |
[
{
"msg_contents": "We've talked before about how the regression tests should be circumspect\nabout what role names they create/drop, so as to avoid possibly blowing\nup an installation's existing users during \"make installcheck\". In\nparticular I believe there was consensus that such names should begin\nwith... |
[
{
"msg_contents": "Hi,\n\nThe $subject says it all. Am I missing something, or is that not ok?\nNow, these branches should never be hit, but it surely isn't good that\nthe corruption will persist on a primary, after it's explicitly been\nfixed on the standby.\n\nGreetings,\n\nAndres Freund\n\n\n-- \nSent via pg... |
[
{
"msg_contents": "After putting \"plperl\" into shared_preload_libraries so that things\nget loaded upon server start, I was surprised to see that each backend\nwas still accessing a handful of perl files the first time it used a\nplperl function.\n\nI see that the cause is src/pl/plperl/plc_trusted.pl, which ... |
[
{
"msg_contents": "Hi hackers!\n\nFollowing is a proposal to add timestamp informations to\n`pg_stat_statements`.\n\n# Use case\n- If we want to gather list and stats for queries executed at least once\nlast 1 hour, we had to reset a hours ago. There is no way if we didn't.\n- If we found some strange query fro... |
[
{
"msg_contents": "Hi\r\n I run a simple SQL with latest PG：\r\npostgres=# explain select * from t1 where id1 in (select id2 from t2 where c1=c2);\r\n QUERY PLAN \r\n------------------------------------------------------------\r\n Seq Scan on t1 (cost=0.00..43... |
[
{
"msg_contents": "Hi,\n\nheap_update() retries pinning the vm pinning, as explained in the\nfollowing comment:\n\n\t/*\n\t * Before locking the buffer, pin the visibility map page if it appears to\n\t * be necessary. Since we haven't got the lock yet, someone else might be\n\t * in the middle of changing this... |
[
{
"msg_contents": "While reading the logical decoding code I noticed a few supposedly mistyped\ncomments, see the diff below.\n\nBesides that, output_plugin_options argument of CreateInitDecodingContext\nfunction is unused, and the function passes NIL to the corresponding argument\nof StartupDecodingContext. Th... |
[
{
"msg_contents": "When I updated our copy of the IANA timezone library back in March\n(commit 1c1a7cbd6), I noted that we ought to consider back-patching\nthose changes once they'd settled out in HEAD. Now that the code\nhas survived a couple of months of beta testing, I think it is time\nto do that.\n\nI wen... |
[
{
"msg_contents": "Hi All,\n\nDuring the discussion of supporting multi tenancy with the help of\nrow level security, because of some problems of executing any\npolicy that was created by an unprivileged user [1].\n\nTo avoid that problem, If we have some kind of new mechanism to\nGRANT/REVOKE only CREATE POLIC... |
[
{
"msg_contents": "Hi all,\n\nThe file 006_logical_decoding_timelines.pl was removed by the commit c1543a8.\nBut currently 005_***.pl and 007_***.pl exist on source tree.\nShould we change its file number to 006?\n\nPlease find attached patch renames 007_sync_rep.pl to 006_sync_rep.pl.\n\nRegards,\n\n--\nMasahi... |
[
{
"msg_contents": "Hi,\n\nA few days ago I ran into a problem with the init script packaged in our \ncommunity RPM packages. What happened was that they initiated a restart, \nbut this happened:\n\n# /etc/init.d/postgresql-9.3 restart\nStopping postgresql-9.3 service: [FAILED]\nStartin... |
[
{
"msg_contents": "At PgCon we discussed that Petr Jelinek would be working on the code for an\nin-core logical replication implementation, while I would work on user\ninterface/security models. Petr has been actively working on the code and\nwill post patch in a few weeks, as discussed and agreed. Craig Ringer... |
[
{
"msg_contents": "I can't help noticing that the failure rate on skink has gone from\n\"rare\" to \"100%\" since 3d5b227:\nhttp://buildfarm.postgresql.org/cgi-bin/show_history.pl?nm=skink&br=REL9_4_STABLE\nI think we need to put some effort into figuring out what's up there.\n\nAlso, this morning curculio show... |
[
{
"msg_contents": "Seems you can't use UNION and COLLATE in the same SELECT statement; you\nhave to put the UNION inside of WITH and then do the COLLATE outside:\n\n test=> SELECT 'a-c' AS x UNION ALL SELECT 'ab' AS x ORDER BY 1 COLLATE \"C\";\n ERROR: collations are not supported by type integer\n LINE 1: ..... |
[
{
"msg_contents": "Hi,\n\nI have been trying MADlib [1], a machine-learning library for PostgreSQL,\nand when I was tying it on 9.5 and 9.6beta2, I often got following\nerror on my box.\n\n------------------------------------\nmadpack.py : ERROR : SQL command failed:\nSQL: DROP OWNED BY madlib_19_installcheck C... |
[
{
"msg_contents": "Folks,\n\nPlease find attached a patch which makes it possible to disallow\nUPDATEs and DELETEs which lack a WHERE clause. As this changes query\nbehavior, I've made the new GUCs PGC_SUSET.\n\nWhat say?\n\nThanks to Gurjeet Singh for the idea and Andrew Gierth for the tips\nimplementing.\n\n... |
[
{
"msg_contents": "Hi Hackers,\r\n\r\n\r\nI have been seeing memory usage increasing for a simple plpgsql function. Could you please take a look and check is it a bug?\r\n\r\n\r\nThe function definition is:\r\n\r\n\r\ncreate function f() returns int as\r\n$$DECLARE count int;\r\nBEGIN\r\n count := 1;\r\n ... |
[
{
"msg_contents": "In Danish, the sequence 'aa' is sometimes treated as a single letter\nwhich collates after 'z'.\n\nSome regression tests got into 9.5, and are still in 9.6beta3, which\nfail due to assuming they know how things will sort or compare.\n\nI thought the easiest way to deal with it was just to cha... |
[
{
"msg_contents": "The open items list says this:\n\nheap_update sets xmax and infomask without logging the changes or\nclearing PD_ALL_VISIBLE or visibility map bits\n* volunteer owner wanted\n* This has been buggy essentially forever but the freeze map changes\ngive it new urgency.\n* Andres working on commit... |
[
{
"msg_contents": "Hi,\n\nThe following steps reproduce an error with pg_restore:\n\nDROP TABLE IF EXISTS myTable;\nDROP FUNCTION IF EXISTS myInnerFunction(INTEGER);\nDROP FUNCTION IF EXISTS myOuterFunction(INTEGER);\nDROP SCHEMA IF EXISTS myOtherSchema;\n\nCREATE SCHEMA myOtherSchema;\n\nSET search_path = myPr... |
[
{
"msg_contents": "In\nhttps://www.postgresql.org/message-id/tencent_5C738ECA65BAD6861AA43E8F@qq.com\nit was pointed out that you could get an intra-function-call memory leak\nfrom something like\n\n\tLOOP\n\t BEGIN\n\t EXECUTE 'bogus command';\n\t EXCEPTION WHEN OTHERS THEN\n\t END;\n\tEND LOOP;\n\nThe p... |
[
{
"msg_contents": "Hi,\n\nTo build the representative tuple for each group in hash-aggregates we\ndo:\nstatic AggHashEntry\nlookup_hash_entry(AggState *aggstate, TupleTableSlot *inputslot)\n{\n...\n\t/* if first time through, initialize hashslot by cloning input slot */\n\tif (hashslot->tts_tupleDescriptor == N... |
[
{
"msg_contents": "Hi,\n\nI've previously mentioned (e.g. [1]) that tuple deforming is a serious\nbottlneck. I've also experimented successfully [2] making\nslot_deform_tuple() faster.\n\nBut nontheless, tuple deforming is still a *major* bottleneck in many\ncases, if not the *the* major bottleneck.\n\nWe could... |
[
{
"msg_contents": "Hi all,\n\nSome people may have bumped into the following surprise for VS2015:\nhttps://yro.slashdot.org/story/16/06/10/1350245/visual-studio-2015-c-compiler-secretly-inserts-telemetry-code-into-binaries\n\nVS 2015 is adding calls to telemetry (surprise!) to track activity of\nan application.... |
[
{
"msg_contents": "Hi all,\n\nI am currently playing with extensions. And I found a strange behaviour \nchange with 9.6beta2 and 3 when pg_dumping a database with an extension \nhaving sequences. This looks like a bug, ... unless I did something wrong.\n\nHere is a test case (a simple linux shell script, that c... |
[
{
"msg_contents": "I have created a patch to cache the meta page of Hash index in\nbackend-private memory. This is to save reading the meta page buffer every\ntime when we want to find the bucket page. In “_hash_first” call, we try to\nread meta page buffer twice just to make sure bucket is not split after we\n... |
[
{
"msg_contents": "Hi hackers,\n\nwe are a group of researches that work on temporal databases. Our main focus is\nthe processing of data with time intervals, such as the range types in\nPostgreSQL.\n\nFor this type of processing the range types that are stored with the tuples are\nconsidered to represent the t... |
[
{
"msg_contents": "CREATE DOMAIN text_not_null AS text NOT NULL;\nCREATE TYPE c AS( t text_not_null, i int );\nCREATE TABLE test_table( id serial, c c );\nCREATE OR REPLACE FUNCTION test_func(i test_table) RETURNS oid LANGUAGE \nplpgsql AS $$\nBEGIN\nRETURN pg_typeof(i);\nEND$$;\nSELECT test_func(NULL);\nERROR:... |
[
{
"msg_contents": "Teaser: change made in 9.4 to simplify WAL segment compression\nmade it easier to compress a low-activity-period WAL segment\nfrom 16 MB to about 27 kB ... but much harder to do better than\nthat, as I was previously doing (about two orders of magnitude\nbetter).\n\nAt $work, we have a usuall... |
[
{
"msg_contents": "In light of the fact that it is an endless cause of bugs both in pg and\npotentially to applications, I propose that we cease attempting to\nconform to the spec's definition of IS NULL in favour of the following\nrules:\n\n1. x IS NULL is true if and only if x has the null value (isnull set)... |
[
{
"msg_contents": "Hi,\n\nAs already noted[1], LWLocks don't currently work in DSM segments,\nbecause they use dlist for the list of waiters. Even though all of\nthe waiter nodes are in PGPROC and therefore have stable addresses,\nthe dlist code internally constructs a circular list including\npointers to a sp... |
[
{
"msg_contents": "Hi Team,\n\nCurrently we have a project running with MySQL with YII & Wordpress, Now i\nwant to change the Database from MYSQL to PostgreSQL.\n\nPlease put your inline comments below.\n*[JS:] *Is there any way we can convert MYSQL queries to PostreSQL Queries?\n\n*Your Comment : ?*\n\n\n*[JS:... |
[
{
"msg_contents": "Found a bug:\n\ncreate table foo as select x, floor(random()*100)::int as y,\nfloor(random()*100)::int as z from generate_series(1,1000000) f(x);\n\nexplain select count(y) filter (where y<0.01) from foo where x < 10000;\n\nERROR: variable not found in subplan target list\nSTATEMENT: select... |
[
{
"msg_contents": "Hi all,\n\nLately hamster is failing every 4/5 days on the recovery regression\ntests in 003 covering the recovery targets, with that:\n# Postmaster PID for node \"standby_2\" is 20510\n#\nTimed out while waiting for standby to catch up at\nt/003_recovery_targets.pl line 36.\n\nWhich means th... |
[
{
"msg_contents": "The comment seems to have been copied from ATExecAddColumn, which says:\n\n /*\n * If we are told not to recurse, there had better not be any\n- * child tables; else the addition would put them out of step.\n\nFor ATExecValidateConstraint, it should say something like:\n\n+ * child tables; e... |
[
{
"msg_contents": "Hi all,\n\nI was checking out TAP tests documentation. And I found confusing this \npart of src/test/perl/README file:\n\n my $ret = $node->psql('postgres', 'SELECT 1');\n is($ret, '1', 'SELECT 1 returns 1');\n\nThe returning value of psql() function is the exit code of the psql. \nHe... |
[
{
"msg_contents": "Hi,\n\nI spent some time profiling a simply query with a SUM() aggregate. We've \nmade some big improvements in this area in recent years, but it seems \nthere's still some room for improvement. A lot of CPU time is spent in \nthe numeric add_var() and friends. Which isn't that surprising, I ... |
[
{
"msg_contents": "With the gutting of pg_am in 9.6, there seems to be no longer any way\nfor a query of the system catalogs to discover any of the index\ncapabilities that were formerly columns in pg_am (notably amcanorder,\namcanorderbyop, amclusterable, amsearcharray, amsearchnulls).\n\nAm I missing somethin... |
[
{
"msg_contents": "Example: I have a database cluster initialized with --locale=ru_RU.UTF-8\n(built with NLS). Let's say for some reason, I have client encoding set\nto LATIN1. All error messages come back like this:\n\ntest=> select * from notthere;\nERROR: character with byte sequence 0xd0 0x9e in encoding... |
[
{
"msg_contents": "I was trying to look up the background of this error message:\n\n\"Ispell dictionary supports only \\\"default\\\", \\\"long\\\", and \\\"num\\\" flag\nvalue\"\n\n(src/backend/tsearch/spell.c)\n\nBut I found that this actually talks about Hunspell format dictionaries.\n (So the man page is hu... |
[
{
"msg_contents": "Hello folks,\n\nI've got a small patch I'd like to submit for consideration.\n\nThe scenario involves MSVC builds, where a user can do the following:\n1) Install ActivePerl's latest (5.22 or 5.24).\n2) Add this line to their config.pl file (in src/tools/msvc):\n$config->{perl} = \"C:\\\\Perl6... |
[
{
"msg_contents": "Hello,\n\nThe following article is a very good look at some of our limitations and \nhighlights some of the pains many of us have been working \"around\" since \nwe started using the software.\n\nhttps://eng.uber.com/mysql-migration/\n\nSpecifically:\n\n* Inefficient architecture for writes\n... |
[
{
"msg_contents": "On Thu, Jul 21, 2016 at 12:06 PM, Robert Haas <robertmhaas@gmail.com> wrote:\n> On Wed, Jul 20, 2016 at 9:15 PM, Noah Misch <noah@leadboat.com> wrote:\n>> This PostgreSQL 9.6 open item now needs a permanent owner. Would any other\n>> committer like to take ownership? If this role interests ... |
[
{
"msg_contents": "Hi,\n\nAs previously mentioned, dynahash isn't particularly fast. In many cases\nthat doesn't particularly matter. But e.g. hash aggregation and bitmap\nindex scans are quite sensitive to hash performance.\n\nThe biggest problems with dynahash (also discussed at [1]) are\n\na) two level struc... |
[
{
"msg_contents": "Hi,\n\nI noticed that currently the core doesn't show any information on the \ntarget relations involved in a foreign/custom join in EXPLAIN, by \nitself. Here is an example:\n\n-- join two tables\nEXPLAIN (COSTS false, VERBOSE)\nSELECT t1.c1, t2.c1 FROM ft1 t1 JOIN ft2 t2 ON (t1.c1 = t2.c... |
[
{
"msg_contents": "Hello\n\nWhile working on some new feature for PostgreSQL (which is still in\ndevelopment and is irrelevant in this context) I noticed that current\nRBTree implementation interface is following:\n\n```\nextern void rb_begin_iterate(RBTree *rb, RBOrderControl ctrl);\nextern RBNode *rb_iterate(... |
[
{
"msg_contents": "I looked into the problem reported in bug #14265,\nhttps://www.postgresql.org/message-id/20160727005725.7438.26021@wrigleys.postgresql.org\n\nThe core of the problem is a design decision that seems pretty bad in\nhindsight: if we have array-subscripting or field-selection decoration\nin the t... |
[
{
"msg_contents": "Hello hackers,\n\nI noticed that exit_hook_registered variable in start_postmaster() is \nlocal variable. Shouldn't it be a static variable?\n\nI attached a patch. Thank you!\n\n-- \nArtur Zakirov\nPostgres Professional: http://www.postgrespro.com\nRussian Postgres Company\n\n\n\n-- \nSent vi... |
[
{
"msg_contents": "Hello,\n\nWhile testing replication for 9.5, we found that repl-master can\nignore wal_sender_timeout and seemingly waits for TCP\nretransmission timeout for the case of sudden power-off of a\nstandby.\n\nMy investigation told me that the immediate cause could be that\nsecure_write() is calle... |
[
{
"msg_contents": "On Thu, Jul 28, 2016 at 8:44 PM, Amit Kapila <amit.kapila16@gmail.com> wrote:\n> On Tue, Jul 26, 2016 at 11:58 AM, Fujii Masao <masao.fujii@gmail.com> wrote:\n>> On Wed, Jul 13, 2016 at 3:06 AM, Jeff Janes <jeff.janes@gmail.com> wrote:\n>>> On Tue, Jul 12, 2016 at 10:48 AM, Peter Eisentraut\n... |
[
{
"msg_contents": "Hi\n\nFollowing issue exists with PL/Python: when your function takes array as\ninput parameters, processing arrays of fixed-size elements containing null\nvalues is many times slower than processing same array without nulls. Here\nis an example:\n\n-- Function\n\ncreate or replace function t... |
[
{
"msg_contents": "If I understand correctly, we currently deem an update to be non-HOT\nwhenever any indexed column is updated. This is because tuple\nversions created by HOT updates can later be removed by HOT pruning,\nwhich means that they must not be referenced by index entries.\nOtherwise, after HOT prun... |
[
{
"msg_contents": "Hello,\n\nLooking into pqcomm.c, I noticed that the prototype of\nsocket_set_nonblocking defined twice. Actually the prototype is\nnot necessary at all but one may remain as a convention.\n\nIt doesn't no harm so backpatching seems unnecessary. \n\nregards,\n\n-- \nKyotaro Horiguchi\nNTT Open... |
[
{
"msg_contents": "Following Uber's case discussion, I found this talk by Alexey Kopytov to be\nreally interesting:\n http://kaamos.me/talks/pgday16/strongmysql/strongmysql.html (online html,\nin Russian)\n\nI translated it to English:\n\nhttps://www.dropbox.com/s/t6a15s66jxg50tg/mysqlstrong_pgday16russia.pdf?... |
[
{
"msg_contents": "Hi\n\nI discovered that if you build with -DEXEC_BACKEND on a Unix system\nand then try to start a background worker, it dies in\nInitializeLatchSupport:\n\nTRAP: FailedAssertion(\"!(selfpipe_readfd == -1)\", File: \"latch.c\", Line: 161)\n\nThat's because InitPostmasterChild is called twice.... |
[
{
"msg_contents": "we observed that spawning the specified number of parallel workers for\nevery query that satisfies for parallelism is sometimes leading to\nperformance drop compared to improvement during the peak system load\nwith other processes. Adding more processes to the system is leading\nto more conte... |
[
{
"msg_contents": "Hello\n\nSome time ago we discussed an idea of \"fast temporary tables\":\n\nhttps://www.postgresql.org/message-id/20160301182500.2c81c3dc%40fujitsu\n\nIn two words the idea is following.\n\n<The Idea>\n\nPostgreSQL stores information about all relations in pg_catalog. Some\napplications crea... |
[
{
"msg_contents": "$SUBJECT sucks.\n\nCreate a table containing lots of composite arrays:\n\nregression=# create table foo (f1 int8_tbl[]);\nCREATE TABLE\nregression=# insert into foo select array[row(1,2),row(3,4)]::int8_tbl[] from generate_series (1,10000000);\nINSERT 0 10000000\nregression=# vacuum analyze f... |
[
{
"msg_contents": "The CREATE INDEX documentation states:\n\n\"For hash indexes, the value of effective_cache_size is also relevant\nto index creation time: PostgreSQL will use one of two different hash\nindex creation methods depending on whether the estimated index size\nis more or less than effective_cache_s... |
[
{
"msg_contents": "Hi hackers,\n\nAndres Freund asked me off list what I thought about this part of\nexecGrouping.c, which builds a hash from the hashes of several datums\nin a loop:\n\n /* rotate hashkey left 1 bit at each step */\n hashkey = (hashkey << 1) | ((hashkey & 0x80000000) ? 1 : 0);\n ... |
[
{
"msg_contents": "hi,\ncan you prompt a programming libraries - collection of hash-fuctions and\nindexes for all situations from dbms till 3d-graphics?\n\nhi,can you prompt a programming libraries - collection of hash-fuctions and indexes for all situations from dbms till 3d-graphics?",
"msg_date": "Sun, 3... |
[
{
"msg_contents": "Hi\n\nI am working on xmltable function. This function is used for simple data\nextraction from XML documents. In this moment I am working on prototype's\nparser.\n\nThe SQL/XML syntax is:\n\nXMLTABLE (\n xmlquery\n PASSING xmldocument\n [COLUMNS columns_list] )\n\ncolumns_list := column_l... |
[
{
"msg_contents": "Hi all. I know this has been discussed before, I'd like to know what's the\ncurrent position on this.\n\nComparing the performance of the simple vs. extended protocols with pgbench\nyields some extreme results:\n\n$ ./pgbench -T 10 -S -M simple -f /tmp/pgbench.sql pgbench\ntps = 14739.803253 ... |
[
{
"msg_contents": "Both shm_mq.c and nodeGather.c contain instances of this coding pattern:\n\n WaitLatch(MyLatch, WL_LATCH_SET, 0);\n CHECK_FOR_INTERRUPTS();\n ResetLatch(MyLatch);\n\nI believe this is wrong and the CHECK_FOR_INTERRUPTS needs to be before\nor after the two latc... |
[
{
"msg_contents": "Hi,\n\nI noticed that the following note about direct modification via \nGetForeignUpperPaths in fdwhandler.sgml is a bit confusing. We have \nanother approach using PlanDirectModify, so that should be reflected in \nthe note as well. Please find attached a patch.\n\n <function>Plan... |
[
{
"msg_contents": "A few notes on the next PostgreSQL development cycle (the one after 9.6):\n\n- After several rounds of consultations, it has been decided to change\nthe version numbering scheme. Instead of X.Y.Z, future releases will\nhave a two-part version number M.N, where M is the major version number,\... |
[
{
"msg_contents": "As Peter mentioned in\nhttps://www.postgresql.org/message-id/ba76aeb0-2f84-d180-268f-ea0f5ace4a7b@2ndquadrant.com\nthe decision has been taken to simplify our user-facing version numbering\nsystem to be a two-component number. Since there have been questions\nabout the details of that, I wan... |
[
{
"msg_contents": "Hi pgsql-hackers,\n\nFollowing the patch to implement strpos with Boyer-Moore-Horspool,\nit was proposed we bring BMH to LIKE as well.\n\nOriginal thread:\nhttps://www.postgresql.org/message-id/flat/27645.1220635769%40sss.pgh.pa.us#27645.1220635769@sss.pgh.pa.us\n\nI'm a first time hacker and... |
[
{
"msg_contents": "$SUBJECT seems like a pretty bad idea, because it implies a recursive\nentry to ProcessInterrupts and thence to HandleParallelMessages itself.\nBy what reasoning is that call necessary where it's placed?\n\n\t\t\tregards, tom lane\n\n\n-- \nSent via pgsql-hackers mailing list (pgsql-hackers@p... |
[
{
"msg_contents": "I noticed $subject while fooling around with the tqueue.c memory leak\nissues. This does not seem like a good idea to me. At the very least,\nit's a waste of space that could be used for something else, and at the\nworst, it might be a security issue because it leaves security-sensitive\npg... |
[
{
"msg_contents": "As some of you know, I've been working on parallel sort. I think I've\ngone as long as I can without feedback on the design (and I see that\nwe're accepting stuff for September CF now), so I'd like to share what\nI came up with. This project is something that I've worked on\ninconsistently si... |
[
{
"msg_contents": "Attached patch fixes a minor typo in tuplesort.c\n\ns/child content/child context/g\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",
"msg_date": "Tue, ... |
[
{
"msg_contents": "Dear list,\n\nI'm interested in pgsql, and would like to know more about the design\ndecisions behind it's features.\nWhere should I search in order to know more about subjects, for example:\n\n - Why in the roles system, user are actually roles with login attribute\n and not a separate e... |
[
{
"msg_contents": "https://wiki.postgresql.org/wiki/PostgreSQL10_Roadmap\n\n-- \nSimon Riggs 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 sub... |
[
{
"msg_contents": "Hi,\n\nBack in the bug #14231 thread [1], dealing with performance issues in \nreorderbuffer due to excessive number of expensive free() calls, I've \nproposed to resolve that by a custom slab-like memory allocator, \nsuitable for fixed-size allocations. I'd like to put this into the next \nC... |
[
{
"msg_contents": "In my understanding, we don't have any regression test for protocol\nlevel prepared query (we do have SQL level prepared query tests,\nthough). Shouldn't we add those tests to the regression test suites?\n\nBest regards,\n--\nTatsuo Ishii\nSRA OSS, Inc. Japan\nEnglish: http://www.sraoss.co.jp... |
[
{
"msg_contents": "[Sorry for a top post. For unknown reason I couldn' get mails from\npgsql-hackers since this morning and I have to check the archive]\n\n>> In my understanding, we don't have any regression test for protocol\n>> level prepared query (we do have SQL level prepared query tests,\n>> though). Sho... |
[
{
"msg_contents": "Hi,\n\nCould you please let me know if there is a way to get LSN of each\ntransaction by directly communicating with Postgres server and NOT by\naccessing logs.\n\nThanks!\nJoshua\n\nHi,Could you please let me know if there is a way to get LSN of each transaction by directly communicating wit... |
[
{
"msg_contents": "Hi all,\n\nIn 9.6 development cycle, we had been discussed about configuration\nsyntax for a long time while considering expanding.\nAs a result, we had new dedicated language for multiple synchronous\nreplication, but it supports only priority method.\nWe know that quorum commit is very usef... |
[
{
"msg_contents": "This proposal introduces the idea of \"lossy index tuples\", an idea\nthat provides two important optimizations for btrees and potentially\nother index types stimulated by recent blog complaints.\n\nThe two optimizations are Clustered Indexes (mostly for INSERTs) and\nUpdate Duplicate Removal... |
[
{
"msg_contents": "Hello, \n\nI had an inquiry about the following log messages.\n\n2016-07-20 10:16:58.294 JST,,,3240,,578ed102.ca8,1,,2016-07-20 10:16:50 JST,30/75,0,LOG,00000,\"no left sibling (concurrent deletion?) in \"\"some_index_rel\"\"\",,,,,,,,\"_bt_unlink_halfdead_page, nbtpage.c:1643\",\"\"\n2016-07... |
[
{
"msg_contents": "Hi All,\n\nmonitoring.sgml file has the list of all the wait event names that is\nbeing monitored by pg_stat_activity but as one of the LWLock named\n'OldSnapshotTimemapLock' was added recently as the part of git commit\n'848ef42b' -->\"Add the \"snapshot too old\" feature\", this lwlock\ninf... |
[
{
"msg_contents": "Hello,\n\nNeed community's opinion on following behaviour of \\set AUTOCOMMIT\n\nIf \\set AUTOCOMMIT ON is issued after \\set AUTOCOMMIT OFF the commands\nwhich follow after AUTOCOMMIT is set ON are not committed until an explicit\nCOMMIT is issued.\nIts can be surprising to the user to not... |
[
{
"msg_contents": "Hi\n\nCurrent implementation of PL/Python does not allow the use of\nmulti-dimensional arrays, for both input and output parameters. This forces\nend users to introduce workarounds like casting arrays to text before\npassing them to the functions and parsing them after, which is an\nerror-pro... |
[
{
"msg_contents": "Hi all\n\nI think we have a bit of a problem with the behaviour specified for logical\nslots, one that makes it hard to prevent a outdated snapshot or backup of a\nlogical-slot-using downstream from knowing it's missing a chunk of data\nthat's been consumed from a slot. That's not great since... |
[
{
"msg_contents": "\n Hi list.\n\n As has been previously discussed (see \nhttps://www.postgresql.org/message-id/BAY7-F17FFE0E324AB3B642C547E96890%40phx.gbl \nfor instance) varlena fields cannot accept the literal 0x00 value. Sure, \nyou can use bytea, but this hardly a good solution. The problem seems ... |
[
{
"msg_contents": "Hi,\n\ntesting with sqlsmith shows that the following assertion doesn't hold:\n\n FailedAssertion(\"!(XLogCtl->Insert.exclusiveBackup)\", File: \"xlog.c\", Line: 10200)\n\nThe triggering statements always contain a call to pg_start_backup with\nthe third argument 'true', i.e. it's trying t... |
[
{
"msg_contents": "Hi,\n\nthe following statement triggers an assertion in tsearch:\n\nselect ts_delete(array_to_tsvector('{smith,smith,smith}'::text[]), '{smith,smith}'::text[]);\n-- TRAP: FailedAssertion(\"!(k == indices_count)\", File: \"tsvector_op.c\", Line: 511)\n\nregards,\nAndreas\n\n\n-- \nSent via pg... |
[
{
"msg_contents": "Prevent \"snapshot too old\" from trying to return pruned TOAST tuples.\n\nPreviously, we tested for MVCC snapshots to see whether they were too\nold, but not TOAST snapshots, which can lead to complaints about missing\nTOAST chunks if those chunks are subject to early pruning. Ideally,\nthe... |
[
{
"msg_contents": "Hi all,\n\nWhile reviewing freeze map code, Andres pointed out[1] that\nlazy_scan_heap could accesses visibility map twice and its logic is\nseems a bit tricky.\nAs discussed before, it's not nice especially when large relation is\nentirely frozen.\n\nI posted the patch for that before but si... |
[
{
"msg_contents": "Hello,\n\nI'd like to propose changing the default value of update_process_title to off, at least on Windows. I'll submit a patch if we see no big problem.\n\n\nPROBLEM\n========================================\n\nOur customer is trying to certify PostgreSQL with their packaged software prod... |
[
{
"msg_contents": "Write Amplification Reduction Method (WARM)\n====================================\n\nA few years back, we developed HOT to address the problem associated with\nMVCC and frequent updates and it has served us very well. But in the light\nof Uber's recent technical blog highlighting some of the ... |
[
{
"msg_contents": "Hi all,\n\nI was looking through the buffer manager's code and have noticed that \nfunction PinBuffer has an unused 'strategy' argument. It's seems that \nafter refactoring made by Alexander Korotkov and Andres Freund \n(48354581a49c30f5757c203415aa8412d85b0f70) it became useless. The \nattac... |
[
{
"msg_contents": "Recently I've encountered a strange crash while calling elog(ERROR, \"...\") \nafter the WaitForBackgroundWorkerShutdown() function. It turns out that \n_returns_ inside the PG_TRY()..PG_CATCH() block are *highly* undesirable, \nsince they leave PG_exception_stack pointing to a local struct i... |
[
{
"msg_contents": "I am attaching the patch to improve some coverage of hash index code [1].\nI have added some basic tests, which mainly covers overflow pages. It took\n2 sec extra time in my machine in parallel schedule.\n\n\n\n\nHit Total Coverage\nold tests Line Coverage 780 1478 52.7\n\nFunction Coverage 6... |
[
{
"msg_contents": "Here are two WIP patches to improve the DefElem list processing that is\nused by many utility commands.\n\nOne factors out the duplicate checks, which are currently taking up a\nlot of space with duplicate code. I haven't applied this everywhere\nyet, but the patch shows how much boring code... |
[
{
"msg_contents": "\"\\echo\" has \"\\qecho\" - I'm basically looking for a \"\\qprint\"\n\n\"\\write\" doesn't apply\n\nThe following doesn't work either...\n\n#bash (stock Ubuntu 14.04)\npsql --set=query_in_var='SELECT version();' > /dev/null <<'SQL'\n\\o /tmp/psql-test.txt\n\\set ECHO queries\n--still ends u... |
[
{
"msg_contents": "I'm trying to run pgbench on a moderately beefy machine (4-core 3.4GHz\nwith 32G of ram and md mirrored spinning rust drives) at scale 300\nwith 32 clients with duration of 15min. I'm getting TPS numbers\nbetween 60-150 which seems surprisingly low to me and also to several\npeople on IRC.\n\... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.