agora inbox for [email protected]
help / color / mirror / Atom feedRe: Updated tsearch documentation
1625+ messages / 5 participants
[nested] [flat]
* Re: Updated tsearch documentation
@ 2007-07-17 05:20 Bruce Momjian <[email protected]>
0 siblings, 1 reply; 1625+ messages in thread
From: Bruce Momjian @ 2007-07-17 05:20 UTC (permalink / raw)
To: Oleg Bartunov <[email protected]>; +Cc: Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
I think the tsearch documentation is nearing completion:
http://momjian.us/expire/fulltext/HTML/textsearch.html
but I am not happy with how tsearch is enabled in a user table:
http://momjian.us/expire/fulltext/HTML/textsearch-app-tutorial.html
Aside from the fact that it needs more examples, it only illustrates an
example where someone creates a table, populates it, then adds a
tsvector column, populates that, then creates an index.
That seems quite inflexible. Is there a way to avoid having a separate
tsvector column? What happens if the table is dynamic? How is that
column updated based on table changes? Triggers? Where are the
examples? Can you create an index like this:
CREATE INDEX textsearch_id ON pgweb USING gin(to_tsvector(column));
That avoids having to have a separate column because you can just say:
WHERE to_query('XXX') @@ to_tsvector(column)
How do we make sure that the to_query is using the same text search
configuration as the 'column' or index? Perhaps we should suggest:
CREATE INDEX textsearch_idx ON pgweb USING gin(to_tsvector('english',column));
so that at least the configuration is documented in the index.
--
Bruce Momjian <[email protected]> http://momjian.us
EnterpriseDB http://www.enterprisedb.com
+ If your life is a hard drive, Christ can be your backup. +
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-17 08:14 Oleg Bartunov <[email protected]>
parent: Bruce Momjian <[email protected]>
0 siblings, 2 replies; 1625+ messages in thread
From: Oleg Bartunov @ 2007-07-17 08:14 UTC (permalink / raw)
To: Bruce Momjian <[email protected]>; +Cc: Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
On Tue, 17 Jul 2007, Bruce Momjian wrote:
> I think the tsearch documentation is nearing completion:
>
> http://momjian.us/expire/fulltext/HTML/textsearch.html
>
> but I am not happy with how tsearch is enabled in a user table:
>
> http://momjian.us/expire/fulltext/HTML/textsearch-app-tutorial.html
>
> Aside from the fact that it needs more examples, it only illustrates an
> example where someone creates a table, populates it, then adds a
> tsvector column, populates that, then creates an index.
>
> That seems quite inflexible. Is there a way to avoid having a separate
> tsvector column? What happens if the table is dynamic? How is that
> column updated based on table changes? Triggers? Where are the
> examples? Can you create an index like this:
I agree, that there are could be more examples, but text search doesn't
require something special !
*Example* of trigger function is documented on
http://momjian.us/expire/fulltext/HTML/textsearch-opfunc.html
>
> CREATE INDEX textsearch_id ON pgweb USING gin(to_tsvector(column));
>
> That avoids having to have a separate column because you can just say:
>
> WHERE to_query('XXX') @@ to_tsvector(column)
yes, it's possible, but without ranking, since currently it's impossible
to store any information in index (it's pg's feature). btw, this should
works and for GiST index also.
That kind of search is useful if there is another natural ordering of search
results, for example, by timestamp.
>
> How do we make sure that the to_query is using the same text search
> configuration as the 'column' or index? Perhaps we should suggest:
please, keep in mind, it's not mandatory to use the same configuration
at search time, that was used at index creation.
>
> CREATE INDEX textsearch_idx ON pgweb USING gin(to_tsvector('english',column));
>
> so that at least the configuration is documented in the index.
yes, it's better to always explicitly specify configuration name and not
rely on default configuration.
Unfortunately, configuration name doesn't saved in the index.
Regards,
Oleg
_____________________________________________________________
Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
Sternberg Astronomical Institute, Moscow University, Russia
Internet: [email protected], http://www.sai.msu.su/~megera/
phone: +007(495)939-16-83, +007(495)939-23-83
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-17 09:58 Oleg Bartunov <[email protected]>
parent: Oleg Bartunov <[email protected]>
1 sibling, 0 replies; 1625+ messages in thread
From: Oleg Bartunov @ 2007-07-17 09:58 UTC (permalink / raw)
To: Bruce Momjian <[email protected]>; +Cc: Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
On Tue, 17 Jul 2007, Oleg Bartunov wrote:
> On Tue, 17 Jul 2007, Bruce Momjian wrote:
>
>> I think the tsearch documentation is nearing completion:
>>
>> http://momjian.us/expire/fulltext/HTML/textsearch.html
>>
>> but I am not happy with how tsearch is enabled in a user table:
>>
>> http://momjian.us/expire/fulltext/HTML/textsearch-app-tutorial.html
>>
>> Aside from the fact that it needs more examples, it only illustrates an
>> example where someone creates a table, populates it, then adds a
>> tsvector column, populates that, then creates an index.
>>
>> That seems quite inflexible. Is there a way to avoid having a separate
>> tsvector column? What happens if the table is dynamic? How is that
>> column updated based on table changes? Triggers? Where are the
>> examples? Can you create an index like this:
>
> I agree, that there are could be more examples, but text search doesn't
> require something special !
> *Example* of trigger function is documented on
> http://momjian.us/expire/fulltext/HTML/textsearch-opfunc.html
>
Bruce,
below is an example of trigger for insert/update of example table
create function pgweb_update() returns trigger as
$$
BEGIN
NEW.textsearch_index=
setweight( to_tsvector( coalesce (title,'')), 'A' ) || ' ' ||
setweight( to_tsvector(coalesce (body,'')),'D'); RETURN NEW;
END;
$$
language plpgsql;
CREATE TRIGGER fts_update BEFORE INSERT OR UPDATE ON pgweb
FOR EACH ROW EXECUTE PROCEDURE pgweb_update();
>
>>
>> CREATE INDEX textsearch_id ON pgweb USING gin(to_tsvector(column));
>>
>> That avoids having to have a separate column because you can just say:
>>
>> WHERE to_query('XXX') @@ to_tsvector(column)
>
> yes, it's possible, but without ranking, since currently it's impossible to
> store any information in index (it's pg's feature). btw, this should
> works and for GiST index also.
>
> That kind of search is useful if there is another natural ordering of search
> results, for example, by timestamp.
>
>>
>> How do we make sure that the to_query is using the same text search
>> configuration as the 'column' or index? Perhaps we should suggest:
>
> please, keep in mind, it's not mandatory to use the same configuration
> at search time, that was used at index creation.
>
one example is when text search index created without taking into account
stop-words. Then you could search famous 'to be or not to be' with the
same configuration, or ignore stop words with other.
>>
>> CREATE INDEX textsearch_idx ON pgweb USING
>> gin(to_tsvector('english',column));
>>
>> so that at least the configuration is documented in the index.
>
> yes, it's better to always explicitly specify configuration name and not rely
> on default configuration. Unfortunately, configuration name doesn't saved in
> the index.
>
> Regards,
> Oleg
> _____________________________________________________________
> Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
> Sternberg Astronomical Institute, Moscow University, Russia
> Internet: [email protected], http://www.sai.msu.su/~megera/
> phone: +007(495)939-16-83, +007(495)939-23-83
>
> ---------------------------(end of broadcast)---------------------------
> TIP 4: Have you searched our list archives?
>
> http://archives.postgresql.org
>
Regards,
Oleg
_____________________________________________________________
Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
Sternberg Astronomical Institute, Moscow University, Russia
Internet: [email protected], http://www.sai.msu.su/~megera/
phone: +007(495)939-16-83, +007(495)939-23-83
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-17 21:24 Bruce Momjian <[email protected]>
parent: Oleg Bartunov <[email protected]>
1 sibling, 2 replies; 1625+ messages in thread
From: Bruce Momjian @ 2007-07-17 21:24 UTC (permalink / raw)
To: Oleg Bartunov <[email protected]>; +Cc: Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
Oleg Bartunov wrote:
> On Tue, 17 Jul 2007, Bruce Momjian wrote:
>
> > I think the tsearch documentation is nearing completion:
> >
> > http://momjian.us/expire/fulltext/HTML/textsearch.html
> >
> > but I am not happy with how tsearch is enabled in a user table:
> >
> > http://momjian.us/expire/fulltext/HTML/textsearch-app-tutorial.html
> >
> > Aside from the fact that it needs more examples, it only illustrates an
> > example where someone creates a table, populates it, then adds a
> > tsvector column, populates that, then creates an index.
> >
> > That seems quite inflexible. Is there a way to avoid having a separate
> > tsvector column? What happens if the table is dynamic? How is that
> > column updated based on table changes? Triggers? Where are the
> > examples? Can you create an index like this:
>
> I agree, that there are could be more examples, but text search doesn't
> require something special !
> *Example* of trigger function is documented on
> http://momjian.us/expire/fulltext/HTML/textsearch-opfunc.html
Yes, I see that in tsearch() here:
http://momjian.us/expire/fulltext/HTML/textsearch-opfunc.html#TEXTSEARC$
I assume my_filter_name is optional right? I have updated the prototype
to be:
tsearch([vector_column_name], [my_filter_name], text_column_name [, ... ])
Is this accurate? What does this text below it mean?
There can be many functions and text columns specified in a tsearch()
trigger. The following rule is used: a function is applied to all
subsequent TEXT columns until the next matching column occurs.
Why are we allowing my_filter_name here? Isn't that something for a
custom trigger. Is calling it tsearch() a good idea? Why not
tsvector_trigger().
> > CREATE INDEX textsearch_id ON pgweb USING gin(to_tsvector(column));
> >
> > That avoids having to have a separate column because you can just say:
> >
> > WHERE to_query('XXX') @@ to_tsvector(column)
>
> yes, it's possible, but without ranking, since currently it's impossible
> to store any information in index (it's pg's feature). btw, this should
> works and for GiST index also.
What if they use @@@. Wouldn't that work because it is going to check
the heap?
> That kind of search is useful if there is another natural ordering of search
> results, for example, by timestamp.
>
> >
> > How do we make sure that the to_query is using the same text search
> > configuration as the 'column' or index? Perhaps we should suggest:
>
> please, keep in mind, it's not mandatory to use the same configuration
> at search time, that was used at index creation.
Well, sort of. If you have stop words in the tquery configuration, you
aren't going to hit any matches in the tsvector, right? Same for
synonymns, I suppose. I can see that stemming would work if there was a
mismatch between tsquery and tsvector.
> > CREATE INDEX textsearch_idx ON pgweb USING gin(to_tsvector('english',column));
> >
> > so that at least the configuration is documented in the index.
>
> yes, it's better to always explicitly specify configuration name and not
> rely on default configuration.
> Unfortunately, configuration name doesn't saved in the index.
I was more concerned that there is nothing documenting the configuration
used by the index or the tsvector table column trigger. By doing:
CREATE INDEX textsearch_idx ON pgweb USING gin(to_tsvector('english',column));
you guarantee that the index uses 'english' for all its entries. If you
omit the 'english' or use a different configuration, it will heap scan
the table, which at least gives the right answer.
Also, how do you guarantee that tsearch() triggers always uses the same
configuration? The existing tsearch() API seems to make that
impossible. I am wondering if we need to add the configuration name as
a mandatory parameter to tsearch().
--
Bruce Momjian <[email protected]> http://momjian.us
EnterpriseDB http://www.enterprisedb.com
+ If your life is a hard drive, Christ can be your backup. +
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-17 21:35 Michael Glaesemann <[email protected]>
parent: Bruce Momjian <[email protected]>
1 sibling, 1 reply; 1625+ messages in thread
From: Michael Glaesemann @ 2007-07-17 21:35 UTC (permalink / raw)
To: Bruce Momjian <[email protected]>; +Cc: Oleg Bartunov <[email protected]>; Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
On Jul 17, 2007, at 16:24 , Bruce Momjian wrote:
> I assume my_filter_name is optional right? I have updated the
> prototype
> to be:
>
> tsearch([vector_column_name], [my_filter_name], text_column_name
> [, ... ])
Just a style point, but would [filter_name] be better than
[my_filter_name]? You're not qualifying the others with my_ ... or is
there something you want to tell us, Bruce? :)
Michael Glaesemann
grzm seespotcode net
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-17 21:46 Bruce Momjian <[email protected]>
parent: Michael Glaesemann <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Bruce Momjian @ 2007-07-17 21:46 UTC (permalink / raw)
To: Michael Glaesemann <[email protected]>; +Cc: Oleg Bartunov <[email protected]>; Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
Michael Glaesemann wrote:
>
> On Jul 17, 2007, at 16:24 , Bruce Momjian wrote:
>
> > I assume my_filter_name is optional right? I have updated the
> > prototype
> > to be:
> >
> > tsearch([vector_column_name], [my_filter_name], text_column_name
> > [, ... ])
>
> Just a style point, but would [filter_name] be better than
> [my_filter_name]? You're not qualifying the others with my_ ... or is
> there something you want to tell us, Bruce? :)
Agreed. Done.
--
Bruce Momjian <[email protected]> http://momjian.us
EnterpriseDB http://www.enterprisedb.com
+ If your life is a hard drive, Christ can be your backup. +
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-18 12:50 Oleg Bartunov <[email protected]>
parent: Bruce Momjian <[email protected]>
1 sibling, 1 reply; 1625+ messages in thread
From: Oleg Bartunov @ 2007-07-18 12:50 UTC (permalink / raw)
To: Bruce Momjian <[email protected]>; +Cc: Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
On Tue, 17 Jul 2007, Bruce Momjian wrote:
> Oleg Bartunov wrote:
>> On Tue, 17 Jul 2007, Bruce Momjian wrote:
>>
>>> I think the tsearch documentation is nearing completion:
>>>
>>> http://momjian.us/expire/fulltext/HTML/textsearch.html
>>>
>>> but I am not happy with how tsearch is enabled in a user table:
>>>
>>> http://momjian.us/expire/fulltext/HTML/textsearch-app-tutorial.html
>>>
>>> Aside from the fact that it needs more examples, it only illustrates an
>>> example where someone creates a table, populates it, then adds a
>>> tsvector column, populates that, then creates an index.
>>>
>>> That seems quite inflexible. Is there a way to avoid having a separate
>>> tsvector column? What happens if the table is dynamic? How is that
>>> column updated based on table changes? Triggers? Where are the
>>> examples? Can you create an index like this:
>>
>> I agree, that there are could be more examples, but text search doesn't
>> require something special !
>> *Example* of trigger function is documented on
>> http://momjian.us/expire/fulltext/HTML/textsearch-opfunc.html
>
> Yes, I see that in tsearch() here:
>
> http://momjian.us/expire/fulltext/HTML/textsearch-opfunc.html#TEXTSEARC$
>
> I assume my_filter_name is optional right? I have updated the prototype
> to be:
>
> tsearch([vector_column_name], [my_filter_name], text_column_name [, ... ])
>
> Is this accurate? What does this text below it mean?
no, this in inaccurate. First, vector_column_name is not optional argument,
it's a name of tsvector column name.
>
> There can be many functions and text columns specified in a tsearch()
> trigger. The following rule is used: a function is applied to all
> subsequent TEXT columns until the next matching column occurs.
The idea, is to provide user to preprocess text before applying
tsearch machinery. my_filter_name() preprocess text_column_name1,
text_column_name2,....
The original syntax allows to specify for every text columns their
preprocessing functions.
So, I suggest to keep original syntax, change 'vector_column_name' to
'tsvector_column_name'.
>
> Why are we allowing my_filter_name here? Isn't that something for a
> custom trigger. Is calling it tsearch() a good idea? Why not
> tsvector_trigger().
I don't see any benefit from the tsvector_trigger() name. If you want to add
some semantic, than tsvector_update_trigger() would be better. Anyway,
this trigger is an illustration.
>
>>> CREATE INDEX textsearch_id ON pgweb USING gin(to_tsvector(column));
>>>
>>> That avoids having to have a separate column because you can just say:
>>>
>>> WHERE to_query('XXX') @@ to_tsvector(column)
>>
>> yes, it's possible, but without ranking, since currently it's impossible
>> to store any information in index (it's pg's feature). btw, this should
>> works and for GiST index also.
>
> What if they use @@@. Wouldn't that work because it is going to check
> the heap?
It would work, it'd recalculate to_tsvector(column) for rows found
( for GiST - to remove false hits and for weight information, for
GIN - for weight information only).
>
>> That kind of search is useful if there is another natural ordering of search
>> results, for example, by timestamp.
>>
>>>
>>> How do we make sure that the to_query is using the same text search
>>> configuration as the 'column' or index? Perhaps we should suggest:
>>
>> please, keep in mind, it's not mandatory to use the same configuration
>> at search time, that was used at index creation.
>
> Well, sort of. If you have stop words in the tquery configuration, you
> aren't going to hit any matches in the tsvector, right? Same for
> synonymns, I suppose. I can see that stemming would work if there was a
> mismatch between tsquery and tsvector.
>
>>> CREATE INDEX textsearch_idx ON pgweb USING gin(to_tsvector('english',column));
>>>
>>> so that at least the configuration is documented in the index.
>>
>> yes, it's better to always explicitly specify configuration name and not
>> rely on default configuration.
>> Unfortunately, configuration name doesn't saved in the index.
as Teodor corrected me, index doesn't know about configuration at all !
What accurate user could do, is to provide configuration name in the
comment for tsvector column. Configuration name is an accessory of
to_tsvector() function.
In principle, tsvector as any data type could be obtained by any other ways,
for example, OpenFTS construct tsvector following its own rules.
>
> I was more concerned that there is nothing documenting the configuration
> used by the index or the tsvector table column trigger. By doing:
again, index has nothing with configuration name.
Our trigger function is an example, which uses default configuration name.
User could easily write it's own trigger to keep tsvector column up to date
and use configuration name as a parameter.
>
> CREATE INDEX textsearch_idx ON pgweb USING gin(to_tsvector('english',column));
>
> you guarantee that the index uses 'english' for all its entries. If you
> omit the 'english' or use a different configuration, it will heap scan
> the table, which at least gives the right answer.
sometimes it's useful not to use explicitly configuration name
to be able to use index with different configuration. Just change
tsearch_conf_name.
> Also, how do you guarantee that tsearch() triggers always uses the same
> configuration? The existing tsearch() API seems to make that
> impossible. I am wondering if we need to add the configuration name as
> a mandatory parameter to tsearch().
Using the same tsearch_conf_name, which could be defined by many ways,
you guarantee to use the same configuration.
Regards,
Oleg
_____________________________________________________________
Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
Sternberg Astronomical Institute, Moscow University, Russia
Internet: [email protected], http://www.sai.msu.su/~megera/
phone: +007(495)939-16-83, +007(495)939-23-83
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-18 18:08 Bruce Momjian <[email protected]>
parent: Oleg Bartunov <[email protected]>
0 siblings, 1 reply; 1625+ messages in thread
From: Bruce Momjian @ 2007-07-18 18:08 UTC (permalink / raw)
To: Oleg Bartunov <[email protected]>; +Cc: Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
Oleg Bartunov wrote:
> >> I agree, that there are could be more examples, but text search doesn't
> >> require something special !
> >> *Example* of trigger function is documented on
> >> http://momjian.us/expire/fulltext/HTML/textsearch-opfunc.html
> >
> > Yes, I see that in tsearch() here:
> >
> > http://momjian.us/expire/fulltext/HTML/textsearch-opfunc.html#TEXTSEARC$
> >
> > I assume my_filter_name is optional right? I have updated the prototype
> > to be:
> >
> > tsearch([vector_column_name], [my_filter_name], text_column_name [, ... ])
> >
> > Is this accurate? What does this text below it mean?
>
> no, this in inaccurate. First, vector_column_name is not optional argument,
> it's a name of tsvector column name.
Fixed.
> > There can be many functions and text columns specified in a tsearch()
> > trigger. The following rule is used: a function is applied to all
> > subsequent TEXT columns until the next matching column occurs.
>
> The idea, is to provide user to preprocess text before applying
> tsearch machinery. my_filter_name() preprocess text_column_name1,
> text_column_name2,....
> The original syntax allows to specify for every text columns their
> preprocessing functions.
>
> So, I suggest to keep original syntax, change 'vector_column_name' to
> 'tsvector_column_name'.
OK, change made.
> > Why are we allowing my_filter_name here? Isn't that something for a
> > custom trigger. Is calling it tsearch() a good idea? Why not
> > tsvector_trigger().
>
> I don't see any benefit from the tsvector_trigger() name. If you want to add
> some semantic, than tsvector_update_trigger() would be better. Anyway,
> this trigger is an illustration.
Well, the filter that removes '@' might be an example, but tsearch() is
indeed sort of built-in trigger function to be used for simple cases.
My point is that because it is only for simple cases, why add complexity
and allow a filter? It seems best to just remove the filter idea and
let people write their own triggers if they want that functionality.
> >>> CREATE INDEX textsearch_id ON pgweb USING gin(to_tsvector(column));
> >>>
> >>> That avoids having to have a separate column because you can just say:
> >>>
> >>> WHERE to_query('XXX') @@ to_tsvector(column)
> >>
> >> yes, it's possible, but without ranking, since currently it's impossible
> >> to store any information in index (it's pg's feature). btw, this should
> >> works and for GiST index also.
> >
> > What if they use @@@. Wouldn't that work because it is going to check
> > the heap?
>
> It would work, it'd recalculate to_tsvector(column) for rows found
> ( for GiST - to remove false hits and for weight information, for
> GIN - for weight information only).
Right. Currently to use text search on a table, you have to do three
things:
o add a tsvector column to the table
o add a trigger to keep the tsvector column current
o add an index to the tsvector column
My question is why bother with the first two steps? If you do:
CREATE INDEX textsearch_idx ON pgweb USING gist(to_tsvector('english',column));
you don't need a separate column and a trigger to keep it current. The
index is kept current as part of normal query processing. The only
downside is that you have to do to_tsvector() in the heap to avoid false
hits, but that seems minor compared to the disk savings of not having
the separate column. Is to_tsvector() an expensive function?
> >>> CREATE INDEX textsearch_idx ON pgweb USING gin(to_tsvector('english',column));
> >>>
> >>> so that at least the configuration is documented in the index.
> >>
> >> yes, it's better to always explicitly specify configuration name and not
> >> rely on default configuration.
> >> Unfortunately, configuration name doesn't saved in the index.
>
> as Teodor corrected me, index doesn't know about configuration at all !
> What accurate user could do, is to provide configuration name in the
> comment for tsvector column. Configuration name is an accessory of
> to_tsvector() function.
Well, if you create the index with the configuration name it is
guaranteed to match:
CREATE INDEX textsearch_idx ON pgweb USING gist(to_tsvector('english',column));
-------
And if someone does:
WHERE 'friend'::tsquery @@ to_tsvector('english',column))
the index is used. Now if the default configuration is 'english' and
they use:
WHERE 'friend'::tsquery @@ to_tsvector(column))
the index is not used, but this just a good example of why default
configurations aren't that useful. One problem I see is that if the
default configuration is not 'english', then when the index consults the
heap, it would be using a different configuration and yield incorrect
results. I am unsure how to fix that.
With the trigger idea, you have to be sure your configuration is the same
every time you INSERT/UPDATE the table or the index will have mixed
configuration entries and it will yield incorrect results, aside from
the heap configuration lookup not matching the index.
Once we nail this down we will have to have a documentation section
about configuration mismatches.
> In principle, tsvector as any data type could be obtained by any other ways,
> for example, OpenFTS construct tsvector following its own rules.
>
> >
> > I was more concerned that there is nothing documenting the configuration
> > used by the index or the tsvector table column trigger. By doing:
>
> again, index has nothing with configuration name.
> Our trigger function is an example, which uses default configuration name.
> User could easily write it's own trigger to keep tsvector column up to date
> and use configuration name as a parameter.
Right. I am thinking beyond that issue.
> > CREATE INDEX textsearch_idx ON pgweb USING gin(to_tsvector('english',column));
> >
> > you guarantee that the index uses 'english' for all its entries. If you
> > omit the 'english' or use a different configuration, it will heap scan
> > the table, which at least gives the right answer.
>
> sometimes it's useful not to use explicitly configuration name
> to be able to use index with different configuration. Just change
> tsearch_conf_name.
I assume you are saying the benefit is for tsquery to use a different
configuration, not having some tsvector index entries using different
configurations than others.
> > Also, how do you guarantee that tsearch() triggers always uses the same
> > configuration? The existing tsearch() API seems to make that
> > impossible. I am wondering if we need to add the configuration name as
> > a mandatory parameter to tsearch().
>
> Using the same tsearch_conf_name, which could be defined by many ways,
> you guarantee to use the same configuration.
Yea, I am sure you _can_ do it. The question is how can we make it less
error-prone.
--
Bruce Momjian <[email protected]> http://momjian.us
EnterpriseDB http://www.enterprisedb.com
+ If your life is a hard drive, Christ can be your backup. +
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-18 19:46 Oleg Bartunov <[email protected]>
parent: Bruce Momjian <[email protected]>
0 siblings, 2 replies; 1625+ messages in thread
From: Oleg Bartunov @ 2007-07-18 19:46 UTC (permalink / raw)
To: Bruce Momjian <[email protected]>; +Cc: Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
On Wed, 18 Jul 2007, Bruce Momjian wrote:
>
>>> Why are we allowing my_filter_name here? Isn't that something for a
>>> custom trigger. Is calling it tsearch() a good idea? Why not
>>> tsvector_trigger().
>>
>> I don't see any benefit from the tsvector_trigger() name. If you want to add
>> some semantic, than tsvector_update_trigger() would be better. Anyway,
>> this trigger is an illustration.
>
> Well, the filter that removes '@' might be an example, but tsearch() is
> indeed sort of built-in trigger function to be used for simple cases.
> My point is that because it is only for simple cases, why add complexity
> and allow a filter? It seems best to just remove the filter idea and
> let people write their own triggers if they want that functionality.
If you aware about documentation simplicity than we could just document
two versions:
1. without filter function - simple, well understood syntax
2. with filter function - for advanced users
I don't want to remove the feature which works for year without any problem.
>
>>>>> CREATE INDEX textsearch_id ON pgweb USING gin(to_tsvector(column));
>>>>>
>>>>> That avoids having to have a separate column because you can just say:
>>>>>
>>>>> WHERE to_query('XXX') @@ to_tsvector(column)
>>>>
>>>> yes, it's possible, but without ranking, since currently it's impossible
>>>> to store any information in index (it's pg's feature). btw, this should
>>>> works and for GiST index also.
>>>
>>> What if they use @@@. Wouldn't that work because it is going to check
>>> the heap?
>>
>> It would work, it'd recalculate to_tsvector(column) for rows found
>> ( for GiST - to remove false hits and for weight information, for
>> GIN - for weight information only).
>
> Right. Currently to use text search on a table, you have to do three
> things:
>
> o add a tsvector column to the table
> o add a trigger to keep the tsvector column current
> o add an index to the tsvector column
>
> My question is why bother with the first two steps? If you do:
>
> CREATE INDEX textsearch_idx ON pgweb USING gist(to_tsvector('english',column));
>
> you don't need a separate column and a trigger to keep it current. The
> index is kept current as part of normal query processing. The only
> downside is that you have to do to_tsvector() in the heap to avoid false
> hits, but that seems minor compared to the disk savings of not having
> the separate column. Is to_tsvector() an expensive function?
Bruce, you oversimplify the text search, the document could be fully virtual,
not a column(s), it could be a result of any SQL commands, so it could be
very expensive just to obtain document, and yes, to_tsvector could be
very expensive, depending on the document size, parser and dictionaries used.
And, again, current postgres architecture forces to use heap to store
positional and weight information for ranking.
The use case for what you described is very limited - simple text search
on one/several column of the same table without ranking.
>
>>>>> CREATE INDEX textsearch_idx ON pgweb USING gin(to_tsvector('english',column));
>>>>>
>>>>> so that at least the configuration is documented in the index.
>>>>
>>>> yes, it's better to always explicitly specify configuration name and not
>>>> rely on default configuration.
>>>> Unfortunately, configuration name doesn't saved in the index.
>>
>> as Teodor corrected me, index doesn't know about configuration at all !
>> What accurate user could do, is to provide configuration name in the
>> comment for tsvector column. Configuration name is an accessory of
>> to_tsvector() function.
>
> Well, if you create the index with the configuration name it is
> guaranteed to match:
>
> CREATE INDEX textsearch_idx ON pgweb USING gist(to_tsvector('english',column));
> -------
> And if someone does:
>
> WHERE 'friend'::tsquery @@ to_tsvector('english',column))
>
> the index is used. Now if the default configuration is 'english' and
> they use:
>
> WHERE 'friend'::tsquery @@ to_tsvector(column))
>
> the index is not used, but this just a good example of why default
> configurations aren't that useful. One problem I see is that if the
> default configuration is not 'english', then when the index consults the
> heap, it would be using a different configuration and yield incorrect
> results. I am unsure how to fix that.
again, you consider very simple case and actually, your example is a
good example of usefulness of default configuration ! Just think before
you develop your application, but this is very general rule. There are
zillions situations you could do bad things, after all.
Moreover, consider text search on text column, there is no way to specify
configuration at all ! We rely on default configuration here
CREATE INDEX textsearch_idx ON pgweb USING gin(title);
>
> With the trigger idea, you have to be sure your configuration is the same
> every time you INSERT/UPDATE the table or the index will have mixed
> configuration entries and it will yield incorrect results, aside from
> the heap configuration lookup not matching the index.
>
> Once we nail this down we will have to have a documentation section
> about configuration mismatches.
So what is your proposal ? I'm lost a bit. I suggest to begin new thread :)
>
>> In principle, tsvector as any data type could be obtained by any other ways,
>> for example, OpenFTS construct tsvector following its own rules.
>>
>>>
>>> I was more concerned that there is nothing documenting the configuration
>>> used by the index or the tsvector table column trigger. By doing:
>>
>> again, index has nothing with configuration name.
>> Our trigger function is an example, which uses default configuration name.
>> User could easily write it's own trigger to keep tsvector column up to date
>> and use configuration name as a parameter.
>
> Right. I am thinking beyond that issue.
>
>>> CREATE INDEX textsearch_idx ON pgweb USING gin(to_tsvector('english',column));
>>>
>>> you guarantee that the index uses 'english' for all its entries. If you
>>> omit the 'english' or use a different configuration, it will heap scan
>>> the table, which at least gives the right answer.
>>
>> sometimes it's useful not to use explicitly configuration name
>> to be able to use index with different configuration. Just change
>> tsearch_conf_name.
>
> I assume you are saying the benefit is for tsquery to use a different
> configuration, not having some tsvector index entries using different
> configurations than others.
sure, but not necessarily. You can mix different configurations if they
are 'compatible'. Documents could be created from different sources and
could require different dictionaries. I don't want to limit people
in creating complex applications. If you unsure, then always use
explicit configuration name. What's the problem ?
>
>>> Also, how do you guarantee that tsearch() triggers always uses the same
>>> configuration? The existing tsearch() API seems to make that
>>> impossible. I am wondering if we need to add the configuration name as
>>> a mandatory parameter to tsearch().
>>
>> Using the same tsearch_conf_name, which could be defined by many ways,
>> you guarantee to use the same configuration.
>
> Yea, I am sure you _can_ do it. The question is how can we make it less
> error-prone.
We have only ONE variable - configuration name. It could be explicitly
defined and then there is no problem at all, or specified by
GUC variable tsearch_conf_name. What could be simpler !
The question is do we need to define tsearch_conf_name automagically if
it's not defined ? I inclined don't do that and just issue error.
I believe this is enough error-prone.
Regards,
Oleg
_____________________________________________________________
Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
Sternberg Astronomical Institute, Moscow University, Russia
Internet: [email protected], http://www.sai.msu.su/~megera/
phone: +007(495)939-16-83, +007(495)939-23-83
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-18 23:40 Bruce Momjian <[email protected]>
parent: Oleg Bartunov <[email protected]>
1 sibling, 0 replies; 1625+ messages in thread
From: Bruce Momjian @ 2007-07-18 23:40 UTC (permalink / raw)
To: Oleg Bartunov <[email protected]>; +Cc: Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
Oleg Bartunov wrote:
> On Wed, 18 Jul 2007, Bruce Momjian wrote:
>
> >
> >>> Why are we allowing my_filter_name here? Isn't that something for a
> >>> custom trigger. Is calling it tsearch() a good idea? Why not
> >>> tsvector_trigger().
> >>
> >> I don't see any benefit from the tsvector_trigger() name. If you want to add
> >> some semantic, than tsvector_update_trigger() would be better. Anyway,
> >> this trigger is an illustration.
> >
> > Well, the filter that removes '@' might be an example, but tsearch() is
> > indeed sort of built-in trigger function to be used for simple cases.
> > My point is that because it is only for simple cases, why add complexity
> > and allow a filter? It seems best to just remove the filter idea and
> > let people write their own triggers if they want that functionality.
>
> If you aware about documentation simplicity than we could just document
> two versions:
> 1. without filter function - simple, well understood syntax
> 2. with filter function - for advanced users
>
> I don't want to remove the feature which works for year without any problem.
Yes, this is what I want. I would like to show the simple usage first,
then explain that a more complex usage is possible. This will help
people get started using text search. Triggers and secondary columns
are fine, but to start using it the CREATE INDEX-only case is best. I
don't suggest we remove any capabilities, only suggest simple solutions.
> >>>>> CREATE INDEX textsearch_id ON pgweb USING gin(to_tsvector(column));
> >>>>>
> >>>>> That avoids having to have a separate column because you can just say:
> >>>>>
> >>>>> WHERE to_query('XXX') @@ to_tsvector(column)
> >>>>
> >>>> yes, it's possible, but without ranking, since currently it's impossible
> >>>> to store any information in index (it's pg's feature). btw, this should
> >>>> works and for GiST index also.
> >>>
> >>> What if they use @@@. Wouldn't that work because it is going to check
> >>> the heap?
> >>
> >> It would work, it'd recalculate to_tsvector(column) for rows found
> >> ( for GiST - to remove false hits and for weight information, for
> >> GIN - for weight information only).
> >
> > Right. Currently to use text search on a table, you have to do three
> > things:
> >
> > o add a tsvector column to the table
> > o add a trigger to keep the tsvector column current
> > o add an index to the tsvector column
> >
> > My question is why bother with the first two steps? If you do:
> >
> > CREATE INDEX textsearch_idx ON pgweb USING gist(to_tsvector('english',column));
> >
> > you don't need a separate column and a trigger to keep it current. The
> > index is kept current as part of normal query processing. The only
> > downside is that you have to do to_tsvector() in the heap to avoid false
> > hits, but that seems minor compared to the disk savings of not having
> > the separate column. Is to_tsvector() an expensive function?
>
> Bruce, you oversimplify the text search, the document could be fully virtual,
> not a column(s), it could be a result of any SQL commands, so it could be
> very expensive just to obtain document, and yes, to_tsvector could be
> very expensive, depending on the document size, parser and dictionaries used.
>
> And, again, current postgres architecture forces to use heap to store
> positional and weight information for ranking.
>
> The use case for what you described is very limited - simple text search
> on one/several column of the same table without ranking.
Right, but I bet that that is all the majority of users need, at least
at first as they start to use text search.
> >>>>> CREATE INDEX textsearch_idx ON pgweb USING gin(to_tsvector('english',column));
> >>>>>
> >>>>> so that at least the configuration is documented in the index.
> >>>>
> >>>> yes, it's better to always explicitly specify configuration name and not
> >>>> rely on default configuration.
> >>>> Unfortunately, configuration name doesn't saved in the index.
> >>
> >> as Teodor corrected me, index doesn't know about configuration at all !
> >> What accurate user could do, is to provide configuration name in the
> >> comment for tsvector column. Configuration name is an accessory of
> >> to_tsvector() function.
> >
> > Well, if you create the index with the configuration name it is
> > guaranteed to match:
> >
> > CREATE INDEX textsearch_idx ON pgweb USING gist(to_tsvector('english',column));
> > -------
> > And if someone does:
> >
> > WHERE 'friend'::tsquery @@ to_tsvector('english',column))
> >
> > the index is used. Now if the default configuration is 'english' and
> > they use:
> >
> > WHERE 'friend'::tsquery @@ to_tsvector(column))
> >
> > the index is not used, but this just a good example of why default
> > configurations aren't that useful. One problem I see is that if the
> > default configuration is not 'english', then when the index consults the
> > heap, it would be using a different configuration and yield incorrect
> > results. I am unsure how to fix that.
>
> again, you consider very simple case and actually, your example is a
> good example of usefulness of default configuration ! Just think before
> you develop your application, but this is very general rule. There are
> zillions situations you could do bad things, after all.
Right, but if we can reduce possible errors, that is better, and
embedding the configuration name in the expression index funciton does
that.
> Moreover, consider text search on text column, there is no way to specify
> configuration at all ! We rely on default configuration here
>
> CREATE INDEX textsearch_idx ON pgweb USING gin(title);
Ah, this should be:
CREATE INDEX textsearch_idx ON pgweb USING gin(to_tsvector('english', title));
What happens if you create a GIN index on a text column? Does it
convert it to tsvector automatically?
> > With the trigger idea, you have to be sure your configuration is the same
> > every time you INSERT/UPDATE the table or the index will have mixed
> > configuration entries and it will yield incorrect results, aside from
> > the heap configuration lookup not matching the index.
> >
> > Once we nail this down we will have to have a documentation section
> > about configuration mismatches.
>
> So what is your proposal ? I'm lost a bit. I suggest to begin new thread :)
Well, the topic is tsearch documentation, so I don't see how a new
thread would help us.
My idea is to suggest using expression indexes as a simple way to use
text search on a table, and mention the trigger idea as a more complex
solution. Right now there is no mention of the expression index idea in
the documentation.
> >> sometimes it's useful not to use explicitly configuration name
> >> to be able to use index with different configuration. Just change
> >> tsearch_conf_name.
> >
> > I assume you are saying the benefit is for tsquery to use a different
> > configuration, not having some tsvector index entries using different
> > configurations than others.
>
> sure, but not necessarily. You can mix different configurations if they
> are 'compatible'. Documents could be created from different sources and
> could require different dictionaries. I don't want to limit people
> in creating complex applications. If you unsure, then always use
> explicit configuration name. What's the problem ?
OK, I understand. You can store rows needing different synonym tables
in the same column, and if you use the same synonym configuratin when
searching, that is OK. Again, that is fine, but I would like to give
people a simple way to use text search that doesn't get into that
complexity. I realize you understand it well, but I can tell you that
most people, including me, don't and you have to be simple at first to
get people to understand what is happening.
I am learning about the possibilities as I email you so obviously I
didn't fully understand at first either, and I have been working on this
for a while.
Good documentation lays things out simply then adds
complexity/flexibility after the fundamentals are understood.
> >>> Also, how do you guarantee that tsearch() triggers always uses the same
> >>> configuration? The existing tsearch() API seems to make that
> >>> impossible. I am wondering if we need to add the configuration name as
> >>> a mandatory parameter to tsearch().
> >>
> >> Using the same tsearch_conf_name, which could be defined by many ways,
> >> you guarantee to use the same configuration.
> >
> > Yea, I am sure you _can_ do it. The question is how can we make it less
> > error-prone.
>
> We have only ONE variable - configuration name. It could be explicitly
> defined and then there is no problem at all, or specified by
> GUC variable tsearch_conf_name. What could be simpler !
>
> The question is do we need to define tsearch_conf_name automagically if
> it's not defined ? I inclined don't do that and just issue error.
Agreed. Please throw an error.
--
Bruce Momjian <[email protected]> http://momjian.us
EnterpriseDB http://www.enterprisedb.com
+ If your life is a hard drive, Christ can be your backup. +
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-19 03:27 Bruce Momjian <[email protected]>
parent: Oleg Bartunov <[email protected]>
1 sibling, 1 reply; 1625+ messages in thread
From: Bruce Momjian @ 2007-07-19 03:27 UTC (permalink / raw)
To: Oleg Bartunov <[email protected]>; +Cc: Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
Oleg, Teodor,
I am confused by the following example. How does gin know to create a
tsvector, or does it? Does gist know too?
FYI, at some point we need to chat via instant messenger or IRC to
discuss the open items. My chat information is here:
http://momjian.us/main/contact.html
---------------------------------------------------------------------------
SELECT title
FROM pgweb
WHERE textcat(title,body) @@ plainto_tsquery('create table')
ORDER BY dlm DESC LIMIT 10;
CREATE INDEX pgweb_idx ON pgweb USING gin(textcat(title,body));
--
Bruce Momjian <[email protected]> http://momjian.us
EnterpriseDB http://www.enterprisedb.com
+ If your life is a hard drive, Christ can be your backup. +
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-19 04:59 Oleg Bartunov <[email protected]>
parent: Bruce Momjian <[email protected]>
0 siblings, 1 reply; 1625+ messages in thread
From: Oleg Bartunov @ 2007-07-19 04:59 UTC (permalink / raw)
To: Bruce Momjian <[email protected]>; +Cc: Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
On Wed, 18 Jul 2007, Bruce Momjian wrote:
> Oleg, Teodor,
>
> I am confused by the following example. How does gin know to create a
> tsvector, or does it? Does gist know too?
No, gist doesn't know. I don't remember why, Teodor ?
For GIN see http://archives.postgresql.org/pgsql-hackers/2007-05/msg00625.php
for discussion
>
> FYI, at some point we need to chat via instant messenger or IRC to
> discuss the open items. My chat information is here:
>
> http://momjian.us/main/contact.html
I send you invitation for google talk, I use only chat in gmail.
My gmail account is [email protected]
>
> ---------------------------------------------------------------------------
>
> SELECT title
> FROM pgweb
> WHERE textcat(title,body) @@ plainto_tsquery('create table')
> ORDER BY dlm DESC LIMIT 10;
>
> CREATE INDEX pgweb_idx ON pgweb USING gin(textcat(title,body));
>
>
Regards,
Oleg
_____________________________________________________________
Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
Sternberg Astronomical Institute, Moscow University, Russia
Internet: [email protected], http://www.sai.msu.su/~megera/
phone: +007(495)939-16-83, +007(495)939-23-83
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-25 03:42 Bruce Momjian <[email protected]>
parent: Oleg Bartunov <[email protected]>
0 siblings, 2 replies; 1625+ messages in thread
From: Bruce Momjian @ 2007-07-25 03:42 UTC (permalink / raw)
To: Oleg Bartunov <[email protected]>; +Cc: Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
I have added more documentation to try to show how full text search is
used by user tables. I think this the documentaiton is almost done:
http://momjian.us/expire/fulltext/HTML/textsearch-tables.html
---------------------------------------------------------------------------
Oleg Bartunov wrote:
> On Wed, 18 Jul 2007, Bruce Momjian wrote:
>
> > Oleg, Teodor,
> >
> > I am confused by the following example. How does gin know to create a
> > tsvector, or does it? Does gist know too?
>
> No, gist doesn't know. I don't remember why, Teodor ?
>
> For GIN see http://archives.postgresql.org/pgsql-hackers/2007-05/msg00625.php
> for discussion
>
> >
> > FYI, at some point we need to chat via instant messenger or IRC to
> > discuss the open items. My chat information is here:
> >
> > http://momjian.us/main/contact.html
>
> I send you invitation for google talk, I use only chat in gmail.
> My gmail account is [email protected]
>
> >
> > ---------------------------------------------------------------------------
> >
> > SELECT title
> > FROM pgweb
> > WHERE textcat(title,body) @@ plainto_tsquery('create table')
> > ORDER BY dlm DESC LIMIT 10;
> >
> > CREATE INDEX pgweb_idx ON pgweb USING gin(textcat(title,body));
> >
> >
>
> Regards,
> Oleg
> _____________________________________________________________
> Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
> Sternberg Astronomical Institute, Moscow University, Russia
> Internet: [email protected], http://www.sai.msu.su/~megera/
> phone: +007(495)939-16-83, +007(495)939-23-83
--
Bruce Momjian <[email protected]> http://momjian.us
EnterpriseDB http://www.enterprisedb.com
+ If your life is a hard drive, Christ can be your backup. +
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-25 05:39 Oleg Bartunov <[email protected]>
parent: Bruce Momjian <[email protected]>
1 sibling, 1 reply; 1625+ messages in thread
From: Oleg Bartunov @ 2007-07-25 05:39 UTC (permalink / raw)
To: Bruce Momjian <[email protected]>; +Cc: Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
Bruce,
I sent you link to my wiki page with summary of changes
http://www.sai.msu.su/~megera/wiki/ts_changes
Your documentation looks rather old.
Oleg
On Tue, 24 Jul 2007, Bruce Momjian wrote:
>
> I have added more documentation to try to show how full text search is
> used by user tables. I think this the documentaiton is almost done:
>
> http://momjian.us/expire/fulltext/HTML/textsearch-tables.html
>
> ---------------------------------------------------------------------------
>
> Oleg Bartunov wrote:
>> On Wed, 18 Jul 2007, Bruce Momjian wrote:
>>
>>> Oleg, Teodor,
>>>
>>> I am confused by the following example. How does gin know to create a
>>> tsvector, or does it? Does gist know too?
>>
>> No, gist doesn't know. I don't remember why, Teodor ?
>>
>> For GIN see http://archives.postgresql.org/pgsql-hackers/2007-05/msg00625.php
>> for discussion
>>
>>>
>>> FYI, at some point we need to chat via instant messenger or IRC to
>>> discuss the open items. My chat information is here:
>>>
>>> http://momjian.us/main/contact.html
>>
>> I send you invitation for google talk, I use only chat in gmail.
>> My gmail account is [email protected]
>>
>>>
>>> ---------------------------------------------------------------------------
>>>
>>> SELECT title
>>> FROM pgweb
>>> WHERE textcat(title,body) @@ plainto_tsquery('create table')
>>> ORDER BY dlm DESC LIMIT 10;
>>>
>>> CREATE INDEX pgweb_idx ON pgweb USING gin(textcat(title,body));
>>>
>>>
>>
>> Regards,
>> Oleg
>> _____________________________________________________________
>> Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
>> Sternberg Astronomical Institute, Moscow University, Russia
>> Internet: [email protected], http://www.sai.msu.su/~megera/
>> phone: +007(495)939-16-83, +007(495)939-23-83
>
>
Regards,
Oleg
_____________________________________________________________
Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
Sternberg Astronomical Institute, Moscow University, Russia
Internet: [email protected], http://www.sai.msu.su/~megera/
phone: +007(495)939-16-83, +007(495)939-23-83
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-25 08:39 Dimitri Fontaine <[email protected]>
parent: Bruce Momjian <[email protected]>
1 sibling, 1 reply; 1625+ messages in thread
From: Dimitri Fontaine @ 2007-07-25 08:39 UTC (permalink / raw)
To: pgsql-hackers; +Cc: Bruce Momjian <[email protected]>; Oleg Bartunov <[email protected]>; Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>
Hi,
Le mercredi 25 juillet 2007, Bruce Momjian a écrit :
> I have added more documentation to try to show how full text search is
> used by user tables. I think this the documentaiton is almost done:
>
> http://momjian.us/expire/fulltext/HTML/textsearch-tables.html
I've come to understand that GIN indexes are far more costly to update than
GiST one, and Oleg's wiki advice users to partition data and use GiST index
for live part and GIN index for archive part only.
Is it worth mentioning this into this part of the documentation?
And if mentioned here, partitioning step could certainly be part of the
example... or let it as a user exercise, but then explaining why GIN is a
good choice in the provided example.
Hope this helps, regards,
--
dim
Attachments:
[application/pgp-signature] signature.asc (189B, ../../[email protected]/2-signature.asc)
download
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-26 19:56 Bruce Momjian <[email protected]>
parent: Oleg Bartunov <[email protected]>
0 siblings, 1 reply; 1625+ messages in thread
From: Bruce Momjian @ 2007-07-26 19:56 UTC (permalink / raw)
To: Oleg Bartunov <[email protected]>; +Cc: Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
Oleg Bartunov wrote:
> Bruce,
>
> I sent you link to my wiki page with summary of changes
> http://www.sai.msu.su/~megera/wiki/ts_changes
>
> Your documentation looks rather old.
I have updated it to reflect your changes:
http://momjian.us/expire/fulltext/HTML/textsearch-tables.html
---------------------------------------------------------------------------
>
> Oleg
> On Tue, 24 Jul 2007, Bruce Momjian wrote:
>
> >
> > I have added more documentation to try to show how full text search is
> > used by user tables. I think this the documentaiton is almost done:
> >
> > http://momjian.us/expire/fulltext/HTML/textsearch-tables.html
> >
> > ---------------------------------------------------------------------------
> >
> > Oleg Bartunov wrote:
> >> On Wed, 18 Jul 2007, Bruce Momjian wrote:
> >>
> >>> Oleg, Teodor,
> >>>
> >>> I am confused by the following example. How does gin know to create a
> >>> tsvector, or does it? Does gist know too?
> >>
> >> No, gist doesn't know. I don't remember why, Teodor ?
> >>
> >> For GIN see http://archives.postgresql.org/pgsql-hackers/2007-05/msg00625.php
> >> for discussion
> >>
> >>>
> >>> FYI, at some point we need to chat via instant messenger or IRC to
> >>> discuss the open items. My chat information is here:
> >>>
> >>> http://momjian.us/main/contact.html
> >>
> >> I send you invitation for google talk, I use only chat in gmail.
> >> My gmail account is [email protected]
> >>
> >>>
> >>> ---------------------------------------------------------------------------
> >>>
> >>> SELECT title
> >>> FROM pgweb
> >>> WHERE textcat(title,body) @@ plainto_tsquery('create table')
> >>> ORDER BY dlm DESC LIMIT 10;
> >>>
> >>> CREATE INDEX pgweb_idx ON pgweb USING gin(textcat(title,body));
> >>>
> >>>
> >>
> >> Regards,
> >> Oleg
> >> _____________________________________________________________
> >> Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
> >> Sternberg Astronomical Institute, Moscow University, Russia
> >> Internet: [email protected], http://www.sai.msu.su/~megera/
> >> phone: +007(495)939-16-83, +007(495)939-23-83
> >
> >
>
> Regards,
> Oleg
> _____________________________________________________________
> Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
> Sternberg Astronomical Institute, Moscow University, Russia
> Internet: [email protected], http://www.sai.msu.su/~megera/
> phone: +007(495)939-16-83, +007(495)939-23-83
--
Bruce Momjian <[email protected]> http://momjian.us
EnterpriseDB http://www.enterprisedb.com
+ If your life is a hard drive, Christ can be your backup. +
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-27 06:23 Oleg Bartunov <[email protected]>
parent: Bruce Momjian <[email protected]>
0 siblings, 1 reply; 1625+ messages in thread
From: Oleg Bartunov @ 2007-07-27 06:23 UTC (permalink / raw)
To: Bruce Momjian <[email protected]>; +Cc: Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
On Thu, 26 Jul 2007, Bruce Momjian wrote:
> Oleg Bartunov wrote:
>> Bruce,
>>
>> I sent you link to my wiki page with summary of changes
>> http://www.sai.msu.su/~megera/wiki/ts_changes
>>
>> Your documentation looks rather old.
>
> I have updated it to reflect your changes:
>
> http://momjian.us/expire/fulltext/HTML/textsearch-tables.html
Bruce, I noticed you miss many changes. For example,
options for stemmer has changed (it's documented in my ts_changes),
so in
http://momjian.us/expire/fulltext/HTML/textsearch-tables.html#TEXTSEARCH-TABLES-CONFIGURATION
ALTER TEXT SEARCH DICTIONARY en_stem SET OPTION 'english-utf8.stop';
should be
ALTER TEXT SEARCH DICTIONARY en_stem SET OPTION
'StopFile=english-utf8.stop, Language=english';
Also, this is wrong
DROP TEXT SEARCH CONFIGURATION MAPPING ON pg FOR email, url, sfloat, uri, float;
it should be
ALTER TEXT SEARCH CONFIGURATION pg DROP MAPPING FOR email, url, sfloat, uri, float;
Configuration now doesn't have DEFAULT flag, so \dF should not display 'Y'
=> \dF
pg_catalog | russian | Y
public | pg | Y
This is what I see now
postgres=# \dF public.*
List of fulltext configurations
Schema | Name | Description
--------+------+-------------
public | pg |
>
> ---------------------------------------------------------------------------
>
>
>>
>> Oleg
>> On Tue, 24 Jul 2007, Bruce Momjian wrote:
>>
>>>
>>> I have added more documentation to try to show how full text search is
>>> used by user tables. I think this the documentaiton is almost done:
>>>
>>> http://momjian.us/expire/fulltext/HTML/textsearch-tables.html
>>>
>>> ---------------------------------------------------------------------------
>>>
>>> Oleg Bartunov wrote:
>>>> On Wed, 18 Jul 2007, Bruce Momjian wrote:
>>>>
>>>>> Oleg, Teodor,
>>>>>
>>>>> I am confused by the following example. How does gin know to create a
>>>>> tsvector, or does it? Does gist know too?
>>>>
>>>> No, gist doesn't know. I don't remember why, Teodor ?
>>>>
>>>> For GIN see http://archives.postgresql.org/pgsql-hackers/2007-05/msg00625.php
>>>> for discussion
>>>>
>>>>>
>>>>> FYI, at some point we need to chat via instant messenger or IRC to
>>>>> discuss the open items. My chat information is here:
>>>>>
>>>>> http://momjian.us/main/contact.html
>>>>
>>>> I send you invitation for google talk, I use only chat in gmail.
>>>> My gmail account is [email protected]
>>>>
>>>>>
>>>>> ---------------------------------------------------------------------------
>>>>>
>>>>> SELECT title
>>>>> FROM pgweb
>>>>> WHERE textcat(title,body) @@ plainto_tsquery('create table')
>>>>> ORDER BY dlm DESC LIMIT 10;
>>>>>
>>>>> CREATE INDEX pgweb_idx ON pgweb USING gin(textcat(title,body));
>>>>>
>>>>>
>>>>
>>>> Regards,
>>>> Oleg
>>>> _____________________________________________________________
>>>> Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
>>>> Sternberg Astronomical Institute, Moscow University, Russia
>>>> Internet: [email protected], http://www.sai.msu.su/~megera/
>>>> phone: +007(495)939-16-83, +007(495)939-23-83
>>>
>>>
>>
>> Regards,
>> Oleg
>> _____________________________________________________________
>> Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
>> Sternberg Astronomical Institute, Moscow University, Russia
>> Internet: [email protected], http://www.sai.msu.su/~megera/
>> phone: +007(495)939-16-83, +007(495)939-23-83
>
>
Regards,
Oleg
_____________________________________________________________
Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
Sternberg Astronomical Institute, Moscow University, Russia
Internet: [email protected], http://www.sai.msu.su/~megera/
phone: +007(495)939-16-83, +007(495)939-23-83
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-27 20:29 Bruce Momjian <[email protected]>
parent: Oleg Bartunov <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Bruce Momjian @ 2007-07-27 20:29 UTC (permalink / raw)
To: Oleg Bartunov <[email protected]>; +Cc: Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>; pgsql-hackers
Thanks, I found a few more places that needed updating. It should be
accurate now. Thanks for the report.
---------------------------------------------------------------------------
Oleg Bartunov wrote:
> On Thu, 26 Jul 2007, Bruce Momjian wrote:
>
> > Oleg Bartunov wrote:
> >> Bruce,
> >>
> >> I sent you link to my wiki page with summary of changes
> >> http://www.sai.msu.su/~megera/wiki/ts_changes
> >>
> >> Your documentation looks rather old.
> >
> > I have updated it to reflect your changes:
> >
> > http://momjian.us/expire/fulltext/HTML/textsearch-tables.html
>
>
> Bruce, I noticed you miss many changes. For example,
>
>
> options for stemmer has changed (it's documented in my ts_changes),
> so in
> http://momjian.us/expire/fulltext/HTML/textsearch-tables.html#TEXTSEARCH-TABLES-CONFIGURATION
>
> ALTER TEXT SEARCH DICTIONARY en_stem SET OPTION 'english-utf8.stop';
>
> should be
>
>
> ALTER TEXT SEARCH DICTIONARY en_stem SET OPTION
> 'StopFile=english-utf8.stop, Language=english';
>
>
> Also, this is wrong
>
> DROP TEXT SEARCH CONFIGURATION MAPPING ON pg FOR email, url, sfloat, uri, float;
>
> it should be
>
> ALTER TEXT SEARCH CONFIGURATION pg DROP MAPPING FOR email, url, sfloat, uri, float;
>
> Configuration now doesn't have DEFAULT flag, so \dF should not display 'Y'
>
>
> => \dF
> pg_catalog | russian | Y
> public | pg | Y
>
>
> This is what I see now
>
> postgres=# \dF public.*
> List of fulltext configurations
> Schema | Name | Description
> --------+------+-------------
> public | pg |
>
>
>
> >
> > ---------------------------------------------------------------------------
> >
> >
> >>
> >> Oleg
> >> On Tue, 24 Jul 2007, Bruce Momjian wrote:
> >>
> >>>
> >>> I have added more documentation to try to show how full text search is
> >>> used by user tables. I think this the documentaiton is almost done:
> >>>
> >>> http://momjian.us/expire/fulltext/HTML/textsearch-tables.html
> >>>
> >>> ---------------------------------------------------------------------------
> >>>
> >>> Oleg Bartunov wrote:
> >>>> On Wed, 18 Jul 2007, Bruce Momjian wrote:
> >>>>
> >>>>> Oleg, Teodor,
> >>>>>
> >>>>> I am confused by the following example. How does gin know to create a
> >>>>> tsvector, or does it? Does gist know too?
> >>>>
> >>>> No, gist doesn't know. I don't remember why, Teodor ?
> >>>>
> >>>> For GIN see http://archives.postgresql.org/pgsql-hackers/2007-05/msg00625.php
> >>>> for discussion
> >>>>
> >>>>>
> >>>>> FYI, at some point we need to chat via instant messenger or IRC to
> >>>>> discuss the open items. My chat information is here:
> >>>>>
> >>>>> http://momjian.us/main/contact.html
> >>>>
> >>>> I send you invitation for google talk, I use only chat in gmail.
> >>>> My gmail account is [email protected]
> >>>>
> >>>>>
> >>>>> ---------------------------------------------------------------------------
> >>>>>
> >>>>> SELECT title
> >>>>> FROM pgweb
> >>>>> WHERE textcat(title,body) @@ plainto_tsquery('create table')
> >>>>> ORDER BY dlm DESC LIMIT 10;
> >>>>>
> >>>>> CREATE INDEX pgweb_idx ON pgweb USING gin(textcat(title,body));
> >>>>>
> >>>>>
> >>>>
> >>>> Regards,
> >>>> Oleg
> >>>> _____________________________________________________________
> >>>> Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
> >>>> Sternberg Astronomical Institute, Moscow University, Russia
> >>>> Internet: [email protected], http://www.sai.msu.su/~megera/
> >>>> phone: +007(495)939-16-83, +007(495)939-23-83
> >>>
> >>>
> >>
> >> Regards,
> >> Oleg
> >> _____________________________________________________________
> >> Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
> >> Sternberg Astronomical Institute, Moscow University, Russia
> >> Internet: [email protected], http://www.sai.msu.su/~megera/
> >> phone: +007(495)939-16-83, +007(495)939-23-83
> >
> >
>
> Regards,
> Oleg
> _____________________________________________________________
> Oleg Bartunov, Research Scientist, Head of AstroNet (www.astronet.ru),
> Sternberg Astronomical Institute, Moscow University, Russia
> Internet: [email protected], http://www.sai.msu.su/~megera/
> phone: +007(495)939-16-83, +007(495)939-23-83
--
Bruce Momjian <[email protected]> http://momjian.us
EnterpriseDB http://www.enterprisedb.com
+ If your life is a hard drive, Christ can be your backup. +
^ permalink raw reply [nested|flat] 1625+ messages in thread
* Re: Updated tsearch documentation
@ 2007-07-27 21:59 Bruce Momjian <[email protected]>
parent: Dimitri Fontaine <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Bruce Momjian @ 2007-07-27 21:59 UTC (permalink / raw)
To: Dimitri Fontaine <[email protected]>; +Cc: pgsql-hackers; Oleg Bartunov <[email protected]>; Tom Lane <[email protected]>; Teodor Sigaev <[email protected]>
Dimitri Fontaine wrote:
-- Start of PGP signed section.
> Hi,
>
> Le mercredi 25 juillet 2007, Bruce Momjian a ?crit?:
> > I have added more documentation to try to show how full text search is
> > used by user tables. I think this the documentaiton is almost done:
> >
> > http://momjian.us/expire/fulltext/HTML/textsearch-tables.html
>
> I've come to understand that GIN indexes are far more costly to update than
> GiST one, and Oleg's wiki advice users to partition data and use GiST index
> for live part and GIN index for archive part only.
>
> Is it worth mentioning this into this part of the documentation?
> And if mentioned here, partitioning step could certainly be part of the
> example... or let it as a user exercise, but then explaining why GIN is a
> good choice in the provided example.
Partitioning is already in the documentation:
Partitioning of big collections and the proper use of GiST and GIN
indexes allows the implementation of very fast searches with online
update. Partitioning can be done at the database level using table
inheritance and <varname>constraint_exclusion</>, or distributing
documents over servers and collecting search results using the
<filename>contrib/dblink</> extension module. The latter is possible
because ranking functions use only local information.
I don't see a reason to provide an example beyond the existing examples
of how to do partitioning.
--
Bruce Momjian <[email protected]> http://momjian.us
EnterpriseDB http://www.enterprisedb.com
+ If your life is a hard drive, Christ can be your backup. +
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 21 +++++++++++----------
1 file changed, 11 insertions(+), 10 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 7abdc62f41..586bec8466 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4594,6 +4594,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4651,11 +4652,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
- year_sign, abs(year), abs(mon),
- day_sign, (long long) i64abs(mday),
- sec_sign, (long long) i64abs(hour), abs(min));
- cp += strlen(cp);
+ data_len = sprintf(cp, "%c%d-%d %c%lld %c%lld:%02d:",
+ year_sign, abs(year), abs(mon),
+ day_sign, (long long) i64abs(mday),
+ sec_sign, (long long) i64abs(hour), abs(min));
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4665,16 +4666,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%lld %lld:%02d:",
- (long long) mday, (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld %lld:%02d:",
+ (long long) mday, (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%lld:%02d:", (long long) hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%lld:%02d:", (long long) hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.45.1
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20240912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
* [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls
@ 2024-09-11 04:21 Andy Fan <[email protected]>
0 siblings, 0 replies; 1625+ messages in thread
From: Andy Fan @ 2024-09-11 04:21 UTC (permalink / raw)
sprintf return the number of characters printed (not including the
trailing `\0'), so it is exactly same as strlen. so we can reuse that
value and avoid a strlen call.
---
src/backend/utils/adt/datetime.c | 13 +++++++------
1 file changed, 7 insertions(+), 6 deletions(-)
diff --git a/src/backend/utils/adt/datetime.c b/src/backend/utils/adt/datetime.c
index 8f25c15fcfc..83c3c85305b 100644
--- a/src/backend/utils/adt/datetime.c
+++ b/src/backend/utils/adt/datetime.c
@@ -4717,6 +4717,7 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
int fsec = itm->tm_usec;
bool is_before = false;
bool is_zero = true;
+ int data_len;
/*
* The sign of year and month are guaranteed to match, since they are
@@ -4774,11 +4775,11 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
char sec_sign = (hour < 0 || min < 0 ||
sec < 0 || fsec < 0) ? '-' : '+';
- sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%c%d-%d %c%" PRId64 " %c%" PRId64 ":%02d:",
year_sign, abs(year), abs(mon),
day_sign, i64abs(mday),
sec_sign, i64abs(hour), abs(min));
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
@@ -4788,16 +4789,16 @@ EncodeInterval(struct pg_itm *itm, int style, char *str)
}
else if (has_day)
{
- sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
+ data_len = sprintf(cp, "%" PRId64 " %" PRId64 ":%02d:",
mday, hour, min);
- cp += strlen(cp);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
else
{
- sprintf(cp, "%" PRId64 ":%02d:", hour, min);
- cp += strlen(cp);
+ data_len = sprintf(cp, "%" PRId64 ":%02d:", hour, min);
+ cp += data_len;
cp = AppendSeconds(cp, sec, fsec, MAX_INTERVAL_PRECISION, true);
*cp = '\0';
}
--
2.43.0
--=-=-=
Content-Type: text/x-diff
Content-Disposition: attachment;
filename=v20260912-0004-Make-printtup-a-bit-faster-intermediate-st.patch
^ permalink raw reply [nested|flat] 1625+ messages in thread
end of thread, other threads:[~2024-09-11 04:21 UTC | newest]
Thread overview: 1625+ messages (download: mbox mbox.gz follow: Atom feed)
-- links below jump to the message on this page --
2007-07-17 05:20 Re: Updated tsearch documentation Bruce Momjian <[email protected]>
2007-07-17 08:14 ` Oleg Bartunov <[email protected]>
2007-07-17 09:58 ` Oleg Bartunov <[email protected]>
2007-07-17 21:24 ` Bruce Momjian <[email protected]>
2007-07-17 21:35 ` Michael Glaesemann <[email protected]>
2007-07-17 21:46 ` Bruce Momjian <[email protected]>
2007-07-18 12:50 ` Oleg Bartunov <[email protected]>
2007-07-18 18:08 ` Bruce Momjian <[email protected]>
2007-07-18 19:46 ` Oleg Bartunov <[email protected]>
2007-07-18 23:40 ` Bruce Momjian <[email protected]>
2007-07-19 03:27 ` Bruce Momjian <[email protected]>
2007-07-19 04:59 ` Oleg Bartunov <[email protected]>
2007-07-25 03:42 ` Bruce Momjian <[email protected]>
2007-07-25 05:39 ` Oleg Bartunov <[email protected]>
2007-07-26 19:56 ` Bruce Momjian <[email protected]>
2007-07-27 06:23 ` Oleg Bartunov <[email protected]>
2007-07-27 20:29 ` Bruce Momjian <[email protected]>
2007-07-25 08:39 ` Dimitri Fontaine <[email protected]>
2007-07-27 21:59 ` Bruce Momjian <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20260912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
2024-09-11 04:21 [PATCH v20240912 2/4] Continue to remove some unnecesary strlen calls Andy Fan <[email protected]>
This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox