MIME-Version: 1.0
Content-Type: multipart/mixed;
 boundary="=_42983f71ae2c5bfcd23ac0719a048fe4"
Content-Transfer-Encoding: 8bit
Date: Tue, 24 Sep 2024 14:25:47 +0900
From: torikoshia <torikoshia@oss.nttdata.com>
To: Fujii Masao <masao.fujii@oss.nttdata.com>
Cc: zhjwpku@gmail.com, pgsql-hackers@lists.postgresql.org
Subject: Re: Add new COPY option REJECT_LIMIT
In-Reply-To: <5f807fcf3a36df7ba41464ab40b5c37d@oss.nttdata.com>
References: <63f99327aa6b404cc951217fa3e61fe4@oss.nttdata.com>
 <fab7018f-6e00-4be4-bd1e-4a013096f6c9@oss.nttdata.com>
 <de0551d0f9d9e9072e324e51ed5c426d@oss.nttdata.com>
 <6e3dcdc6-8e18-4716-a23b-3bee316aeaa7@oss.nttdata.com>
 <979c6d306343f3d665d14eab2cd1b7bc@oss.nttdata.com>
 <920a29a36032befbeb355cbdfbbe0f63@oss.nttdata.com>
 <a873643c-e7d1-456c-b16b-6162ab698036@oss.nttdata.com>
 <54bea7dd-94b1-41f1-a4e9-c5c53cc82ce7@oss.nttdata.com>
 <f9feda0ecd4e2e09620a6f9ca8f4aac1@oss.nttdata.com>
 <644a094c-2c0c-4b5f-b151-3677c7de4ee7@oss.nttdata.com>
 <5f807fcf3a36df7ba41464ab40b5c37d@oss.nttdata.com>
User-Agent: Roundcube Webmail/1.4.11
Message-ID: <056a5728cf733685cff7d9b5a8fbb0ad@oss.nttdata.com>
Archived-At: 
 <https://www.postgresql.org/message-id/056a5728cf733685cff7d9b5a8fbb0ad%40oss.nttdata.com>
Precedence: bulk

--=_42983f71ae2c5bfcd23ac0719a048fe4
Content-Transfer-Encoding: 8bit
Content-Type: text/plain; charset=UTF-8;
 format=flowed

Updated the patch.

On 2024-07-23 23:06, torikoshia wrote:

> On Tue, Jul 23, 2024 at 1:35 PM Fujii Masao 
> <masao.fujii@oss.nttdata.com> wrote:
> 
> Thanks for your review.
> 
>> On 2024/07/22 21:37, torikoshia wrote:
>>> On Fri, Jul 19, 2024 at 11:48 PM Junwang Zhao <zhjwpku@gmail.com> 
>>> wrote:
>>> Thanks for the comment.
>>> 
>>>> In patch 0002, the ratio is calculated by the already 
>>>> skipped/processed
>>>> rows, but what if a user wants to copy 1000 rows, and he/she can 
>>>> tolerate
>>>> 10 error rows, so he/she might set *reject_limit 0.01*, but one bad 
>>>> row in the
>>>> first 100 rows will fail the entire command, this might surprise the 
>>>> user.
>>> 
>>> Since the ratio is calculated after all data is processed, the case 
>>> "one bad row in the first 100 rows will fail the entire command" 
>>> doesn't happen:
>> 
>> Yes, but is this the desired behavior when using the ratio threshold?
>> I was thinking that COPY should fail once the error ratio (errors vs.
>> total rows in the input file) reaches the threshold.
> 
> Users might expect like you.
> However, implementing it would need a row number counting feature as
> you pointed out, and it seems an overkill.
> 
> Describing the difference between ratio and number in the manual might 
> help, but
> it might be better to make REJECT_LIMIT support only the number of
> errors and leave it to the user to calculate the number from the
> ratio.
> 
> I'd like to hear if anyone has an opinion on the need for supporting 
> ratio.

Since there was no opinion about it, attached a patch only for 
REJECT_LIMIT specifying number.

>> +      This option must be used with <literal>ON_ERROR</literal> to be 
>> set to
>> +      other than <literal>stop</literal>.
>> 
>> Regarding the ON_ERROR option, now it only has two values.
>> Instead of saying "other than stop," we should simply use "ignore"
>> for clarity and intuition?
> 
> I'll Modify it.
> The reason for the roundabout wording was the expectation that
> on_error would support values other than these in the future, but as
> you point out, there are currently only two.
> 
> 
>> +      When specified <literal>INFINITY</literal>, 
>> <command>COPY</command> ignores all
>> +      the errors. This is a synonym for <literal>ON_ERROR</literal> 
>> <literal>ignore</literal>.
>> 
>> For the INFINITY value, the description is a bit unclear.
>> As I understand it, INFINITY is the default for REJECT_LIMIT.
>> So, if ON_ERROR=ignore is set without specifying REJECT_LIMIT,
>> COPY will ignore all errors, similar to when REJECT_LIMIT=INFINITY is 
>> used.
>> 
>> 
>> In line with my previous suggestion, if we support only REJECT_LIMIT
>> without ON_ERROR, having INFINITY makes sense. However,
>> with ON_ERROR supported, REJECT_LIMIT=INFINITY seems redundant.
>> Users can just set ON_ERROR=ignore to ignore all errors,
>> making INFINITY unnecessary for REJECT_LIMIT. This is open for
>> discussion, but I believe it's better to remove INFINITY from
>> the REJECT_LIMIT options.
> 
> Agreed.
> Unless there are opposing opinions, I'm going to remove 'INFINITY' in
> the next patch.

As there are no opposing opinions, removed 'INFINITY' as well.

>> +               else if (strcmp(defel->defname, "reject_limit") == 0)
>> +               {
>> +                       if (reject_limit_specified)
>> +                               errorConflictingDefElem(defel, 
>> pstate);
>> +                       if (!opts_out->on_error)
>> +                               ereport(ERROR,
>> +                                               
>> (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
>> +                                                errmsg("REJECT_LIMIT 
>> requires ON_ERROR to be set to other than stop")));
>> 
>> Using "ignore" instead of "other than stop" in the error message
>> is clearer and more intuitive.
> 
> Agreed.
> 
> 
>> Checking if ON_ERROR and REJECT_LIMIT are specified should be
>> done after the foreach() processing of the options. Otherwise,
>> if REJECT_LIMIT is specified before ON_ERROR, unexpected errors can 
>> occur.
>> 
>> ---------------
>> =# copy test from '...' WITH (REJECT_LIMIT 7, ON_ERROR 'ignore');
>> ERROR:  REJECT_LIMIT requires ON_ERROR to be set to other than stop
>> ---------------
> 
> Ugh, I'll modify it.
> 
>> +                               ereport(ERROR,
>> +                                               
>> (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
>> +                                                errmsg("exceeded the 
>> number specified by REJECT_LIMIT \"%lld\"",
>> +                                                               (long 
>> long) cstate->opts.reject_limits.num_err)));
>> 
>> The error message isn't clear about what exceeded REJECT_LIMIT.
>> How about saying "skipped more than REJECT_LIMIT rows" or something 
>> instead?
> 
> Agreed.
> 
>> +/*
>> + * A struct to hold reject_limit options, in a parsed form.
>> + * More values to be added in another patch.
>> + */
>> 
>> The latter comment doesn't seem necessary or helpful.
> 
> Agreed.
> 
> [1] 
> https://www.postgresql.org/message-id/CAKFQuwYP91_G6tktYFTZq_CmkZ_%3DzuWjkz1%2B25Nd8bpsrDkx5Q%40mail.gmail.com


On Tue, Jul 23, 2024 at 11:10 PM torikoshia <torikoshia@oss.nttdata.com> 
wrote:
> On 2024-07-23 02:06, Kirill Reshke wrote:

>> If nothing is specified, then the maximum tolerable number of errors
>> is one, right? Should we state  this explicitly in the documentation?

> REJECT_LIMIT now can be used wonly when on_error=ignore, I think the
> default(when only on_error=ignore is specified) is unlimited.
> Anyway, I'm going to add a description about the default.

Added the following description:

+      Just setting <literal>ON_ERROR</literal> to 
<literal>ignore</literal>
+      tolerates unlimited number of errors.

-- 
Regards,

--
Atsushi Torikoshi
NTT DATA Group Corporation
--=_42983f71ae2c5bfcd23ac0719a048fe4
Content-Transfer-Encoding: base64
Content-Type: text/x-diff;
 name=v4-0001-Add-new-COPY-option-REJECT_LIMIT-number.patch
Content-Disposition: attachment;
 filename=v4-0001-Add-new-COPY-option-REJECT_LIMIT-number.patch;
 size=8763
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--=_42983f71ae2c5bfcd23ac0719a048fe4--