perl dbi mysql - value precision - mysql

Question

user#host:~# mysql -V - mysql Ver 14.14 Distrib 5.7.25-28, for debian-linux-gnu (x86_64) using 7.0 running under debian-9,9
user#host:~# uname -a - Linux 4.9.0-8-amd64 #1 SMP Debian 4.9.144-3.1 (2019-02-19) x86_64 GNU/Linux
user#host:~# perl -MDBI -e 'print $DBI::VERSION ."\n";' - 1.636
user#host:~# perl -v This is perl 5, version 24, subversion 1 (v5.24.1) built for x86_64-linux-gnu-thread-multi
mysql> SHOW CREATE TABLE tbl1;
tbl1 | CREATE TABLE `tbl1` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`main_id` bigint(20) NOT NULL DEFAULT '0',
`debet` varchar(255) NOT NULL DEFAULT '',
`kurs` double(20,4) NOT NULL DEFAULT '0.0000',
`summ` double(20,2) NOT NULL DEFAULT '0.00',
`is_sync` int(11) NOT NULL DEFAULT '0',
PRIMARY KEY (`id`),
KEY `main_id` (`main_id`)
) ENGINE=InnoDB AUTO_INCREMENT=70013000018275 DEFAULT CHARSET=utf8
mysql> SELECT * FROM tbl1 WHERE id=70003020040132;
-+---------------+----------------+-------+--------+---------+---------+
| id | main_id | debet | kurs | summ | is_sync |
+----------------+----------------+-------+--------+---------+---------+
| 70003020040132 | 70003020038511 | | 0.0000 | 1798.00 | 0 |
+----------------+----------------+-------+--------+---------+---------+
But when I get this data by perl::DBI module I lose precisions, and values 0.0000 and 1798.00 becomes 0 and 1798.
Code is next:
####
#These 3 subs are connecting to DB, executing query and get data by fetchall_arrayref and coverting undef to NULL.
####
sub DB_connect {
# DataBase Handler
my $dbh = DBI->connect("DBI:mysql:$DBNAME", $DBUSER, $DBPWD,{RaiseError => 0, PrintError => 0, mysql_enable_utf8 => 1}) or die "Error connecting to database: $DBI::errstr";
return $dbh;
}
sub DB_executeQuery {
# Executes SQL query. Return reference to array, or array, according to argv[0]
# argv[0] - "A" returns array, "R" - reference to array
# argv[1] - DB handler from DB_connect
# argv[2] - query to execute
my $choice=shift #_;
my $dbh=shift #_;
my $query=shift #_;
print "$query\n" if $DEBUG>2;
my $sth=$dbh->prepare($query) or die "Error preparing $query for execution: $DBI::errstr";
$sth->execute;
my $retval = $sth->fetchall_arrayref;
if ($choice eq "A" ) {
my #ret_arr=();
foreach my $value (#{ $retval }) {
push #ret_arr,#{ $value };
}
return #ret_arr;
}
elsif ($choice eq "R") {
return $retval;
}
}
sub undef2null {
# argv[1] - reference ro array of values where undef
# values has to be changed to NULL
# Returns array of prepared values: (...) (...) ...
my $ref=shift #_;
my #array=();
foreach my $row (#{ $ref }) {
my $str="";
foreach my $val ( #{ $row} ) {
if (! defined ( $val )) {
$str="$str, NULL";
}
else {
# Escape quotes and other symbols listed in square brackets
$val =~ s/([\"\'])/\\$1/g;
$str="$str, \'$val\'";
}
}
# Remove ', ' at the beginning of each VALUES substring
$str=substr($str,2);
push #array,"($str)";
} # End foreach my $row (#{ $ref_values })
return #array;
} # End undef2null
#### Main call
#...
# Somewhere in code I get data from DB and print it to out file
my #arr_values=();
my #arr_col_names=DB_executeQuery("A",$dbh,qq(SELECT column_name FROM `information_schema`.`columns` WHERE `table_schema` = '$DBNAME' AND `table_name` = '#{ $table }'));
#arr_ids=DB_executeQuery("A",$dbh,qq(SELECT `id` FROM `#{ $table }` WHERE `is_sync`=0));
my $ref_values=DB_executeQuery("R",$dbh,"SELECT * FROM \`#{ $table }\` WHERE \`id\` IN(".join(",",#arr_ids).")");
#arr_values=undef2null($ref_values);
print FOUT "REPLACE INTO \`#{ $table }\` (`".join("`, `",#arr_col_names)."`) VALUES ".(join ", ",#arr_values).";\n";
and as a result I get next string:
REPLACE INTO `pko_plat` (`id`, `main_id`, `debet`, `kurs`, `summ`, `is_sync`) VALUES ('70003020040132', '70003020038511', '', '0', '1798', '0')
in DB it was 0.0000 - become 0, was 1798.00, become 1798
Perl's DBI documentation says it gets data 'as is' into strings, no translations made. But, then, who rounded values?

Answer 1

The rounding you see is happening because of the way you create the columns.
`kurs` double(20,4) NOT NULL DEFAULT '0.0000'
`summ` double(20,2) NOT NULL DEFAULT '0.00'
If you look at the mysql floating point type documentation you will see that you are using the non-standard syntax double(m, d), where the two parameters define how the float is being output.
So in your case the values stored in summ will be displayed with 2 digits behind the point. This means that when perl gets a value out of the table which is 1.0001 in the database, the value that perl gets delivered by the database is rounded to the set number of digits (in this case .00).
Perl in turn interprets this value ("1.00") as a float, and when printed, will not show any trailing zeroes. If you want these you should accommodate for this in your output.
For example: print sprintf("%.2f\n", $summ);
The way I see it you have two ways you can go (if you want to avoid this loss of precision):
Only add numbers with the correct precision to the database (so for 'summ' only two trailing digits, and four for 'kurs'.)
Alter your table creation to the standard syntax for floats and determine the output formatting in Perl (which you will be doing either way):
`kurs` double() NOT NULL DEFAULT '0.0'