Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Data damage when inserting or fetching #18

Open
choroba opened this issue Feb 14, 2020 · 39 comments
Open

Data damage when inserting or fetching #18

choroba opened this issue Feb 14, 2020 · 39 comments

Comments

@choroba
Copy link
Member

choroba commented Feb 14, 2020 •
edited
Loading

Characters out of 7-bit ASCII are often garbled when inserting or fetching to/from a database.

We used the following program to check the behaviour. Interestingly, it shows DBD::Pg, DBD::SQLite, and DBD::MariaDB work correctly. DBD::ODBC fails with any driver we tried (postgres, vertica, mysql); mysql and sqlite through ODBC were not included, but they fail, too.

Note the test doesn't do anything fancy: it just stores a string and retrieves it back and checks the identity.

#!/usr/bin/perl
use strict;
use warnings;
use utf8;
binmode \*STDOUT, ':utf8';
binmode \*STDERR, ':utf8';
use Encode qw{ encode };
use DBI;

sub ords { '(' . (join ', ', map ord, split //, $_[0] // '') . ')' }

my $pg_dbh = eval { DBI->connect("DBI:Pg:database=postgres", "root", "...") } or print "Cannot connect via DBI:Pg: " . ($DBI::errstr || $@) . "\n";

my $mariadb_dbh = eval { DBI->connect("DBI:MariaDB:database=test", "root", "...") } or print "Cannot connect via DBI:MariaDB: " . ($DBI::errstr || $@) . "\n";

my $mysql_dbh = eval { DBI->connect("DBI:mysql:database=test", "root", ""."...", { mysql_enable_utf8 => 1 }) } or print "Cannot connect via DBI:mysql: " . ($DBI::errstr || $@) . "\n";

my $sqlite_dbh = eval { DBI->connect("DBI:SQLite:database=:memory:", "", "", { sqlite_unicode => 1 }) } or print "Cannot connect via DBI:SQLite: " . ($DBI::errstr || $@) . "\n";

my $odbc_sqlite_dbh = eval { DBI->connect("DBI:ODBC:driver=SQLite3;database=:memory:", "", "") } or print "Cannot connect via DBI:ODBC:driver=SQLite3: " . ($DBI::errstr || $@) . "\n";

my $odbc_mysql_dbh = eval { DBI->connect("DBI:ODBC:driver=MySQL;database=test", "root", ""."...") } or print "Cannot connect via DBI:ODBC:driver=MySQL: " . ($DBI::errstr || $@) . "\n";

my $odbc_mariadb_dbh = eval { DBI->connect("DBI:ODBC:driver=MariaDB;database=test", "root", ""."...") } or print "Cannot connect via DBI:ODBC:driver=MariaDB: " . ($DBI::errstr || $@) . "\n";

my $odbc_pg_dbh = eval { DBI->connect("DBI:ODBC:driver=PostgreSQL;database=postgres", "root", ""."...") } or print "Cannot connect via DBI:ODBC:driver=PostgreSQL: " . ($DBI::errstr || $@) . "\n";

my $odbc_vertica_dbh = eval { DBI->connect("DBI:ODBC:driver=vertica;database=verticadb;server=localhost", "root", ""."...") } or print "Cannot connect via DBI:ODBC:driver=vertica: " . ($DBI::errstr || $@) . "\n";

my %hex_sql = (
  'ODBC Vertica Database' => 'TO_HEX(b)',
  Pg => "encode(b, 'hex')",
  'ODBC PostgreSQL' => "encode(b, 'hex')",
  MariaDB => 'HEX(b)',
  'ODBC MariaDB' => 'HEX(b)',
  mysql => 'HEX(b)',
  'ODBC MySQL' => 'HEX(b)',
  SQLite => 'HEX(b)',
  'ODBC SQLite' => 'HEX(b)',
);
my %binary_sql = (
  'ODBC Vertica Database' => 'VARBINARY(10)',
  Pg => 'BYTEA',
  'ODBC PostgreSQL' => 'BYTEA',
  MariaDB => 'VARBINARY(10)',
  'ODBC MariaDB' => 'VARBINARY(10)',
  mysql => 'VARBINARY(10)',
  'ODBC MySQL' => 'VARBINARY(10)',
  SQLite => 'BLOB',
  'ODBC SQLite' => 'BLOB',
);
my %binary_type = (
  Pg => DBI::SQL_VARBINARY,
  'ODBC PostgreSQL' => DBI::SQL_VARBINARY,
  'ODBC Vertica Database' => DBI::SQL_VARBINARY,
  MariaDB => DBI::SQL_VARBINARY,
  'ODBC MariaDB' => DBI::SQL_VARBINARY,
  mysql => DBI::SQL_VARBINARY,
  'ODBC MySQL' => DBI::SQL_VARBINARY,
  SQLite => DBI::SQL_BLOB,
  'ODBC SQLite' => DBI::SQL_VARBINARY,
);

for my $dbh (# $mysql_dbh, $odbc_sqlite_dbh, $odbc_mariadb_dbh
	     $pg_dbh, $mariadb_dbh, $sqlite_dbh, $odbc_mysql_dbh, $odbc_pg_dbh, $odbc_vertica_dbh) {
  next unless $dbh;
  my $driver = $dbh->{Driver}->{Name};
  $driver .= ' ' . $dbh->get_info(17) if $driver =~ /^ODBC/;
  my $desc = '';
  $desc .= ' mode=' . ($dbh->{odbc_has_unicode} ? 'UNICODE' : 'ANSI') if $driver =~ /^ODBC/;
  $dbh->do('DROP TABLE IF EXISTS t');
  for my $val ("\xC3\xA1",
               "\N{U+C3}\N{U+A1}",
               "á",
               "č",
               "\x{263A}",
               "\N{U+263A}",
               "☺",
               "\N{U+11111}"
    ) {
    {
      my $ins = $val;
      $dbh->do("CREATE TABLE t(s VARCHAR(10))");
      my $sth = $dbh->prepare("INSERT INTO t(s) VALUES('$ins')");
      if (not $sth) {
        print $driver . $desc . ' prepare without bind - FAIL' . "\n";
      } else {
        $sth->execute();
        my $fetch = $dbh->selectrow_array("SELECT s FROM t");
        print $driver . $desc . ' p+e without bind - insert: ' . ords($ins) . '; fetch: ' . ords($fetch) . ' - ' . ($ins eq $fetch ? 'OK' : 'FAIL') . "\n";
      }
      $dbh->do("DROP TABLE t");
    }
    {
      my $ins = $val;
      $dbh->do("CREATE TABLE t(s VARCHAR(10))");
      my $sth = $dbh->prepare("INSERT INTO t(s) VALUES(?)");
      $sth->execute($ins);
      my $fetch = $dbh->selectrow_array("SELECT s FROM t");
      print $driver . $desc . ' p+e with bind - insert: ' . ords($ins) . '; fetch: ' . ords($fetch) . ' - ' . ($ins eq $fetch ? 'OK' : 'FAIL') . "\n";
      $dbh->do("DROP TABLE t");
    }
    {
      my $ins = $val;
      $dbh->do("CREATE TABLE t(s VARCHAR(10))");
      $dbh->do("INSERT INTO t(s) VALUES('$ins')");
      my ($fetch) = $dbh->selectrow_array("SELECT s FROM t");
      print $driver . $desc . ' do without bind - insert: ' . ords($ins) . '; fetch: ' . ords($fetch) . ' - ' . ($ins eq $fetch ? 'OK' : 'FAIL') . "\n";

      $dbh->do("DROP TABLE t");
    }
    {
      my $ins = $val;
      $dbh->do("CREATE TABLE t(s VARCHAR(10))");
      $dbh->do("INSERT INTO t(s) VALUES(?)", undef, $ins);
      my ($fetch) = $dbh->selectrow_array("SELECT s FROM t");
      print $driver . $desc . ' do with bind - insert: ' . ords($ins) . '; fetch: ' . ords($fetch) . ' - ' . ($ins eq $fetch ? 'OK' : 'FAIL') . "\n";

      $dbh->do("DROP TABLE t");
    }

    # Binary
    my $hex_sql = $hex_sql{$driver};
    my $binary_sql = $binary_sql{$driver};
    my $binary_type = $binary_type{$driver};
    my $bins = encode('UTF-8', $val);
    for my $upgraded (0, 1) {
      $upgraded ? utf8::upgrade($bins) : utf8::downgrade($bins);
      if ($driver !~ /^ODBC/) {
        $dbh->do("CREATE TABLE t(b $binary_sql)");
        my $sth = $dbh->prepare("INSERT INTO t(b) VALUES(" . $dbh->quote($bins, $binary_type) . ")");
        if (not $sth) {
          print $driver . $desc . ' BIN ' . ($upgraded ? 'upgraded' : 'downgraded') . ' prepare with quote - FAIL' . "\n";
        } else {
          $sth->execute();
          my $fetch = $dbh->selectrow_array("SELECT b FROM t");
          print $driver . $desc . ' BIN ' . ($upgraded ? 'upgraded' : 'downgraded') . ' p+e without bind - insert: ' . ords($bins) . '; fetch: ' . ords($fetch) . ' - ' . ($bins eq $fetch ? 'OK' : 'FAIL') . "\n";
          my $hfetch = pack("H*", $dbh->selectrow_array("SELECT $hex_sql FROM t"));
          print $driver . $desc . ' BIN ' . ($upgraded ? 'upgraded' : 'downgraded') . ' p+e without bind - insert: ' . ords($bins) . '; hex fetch: ' . ords($hfetch) . ' - ' . ($bins eq $hfetch ? 'OK' : 'FAIL') . "\n";
        }
        $dbh->do("DROP TABLE t");
      }
      {
        $dbh->do("CREATE TABLE t(b $binary_sql)");
        my $sth = $dbh->prepare("INSERT INTO t(b) VALUES(?)");
        if (not $sth) {
          print $driver . $desc . ' BIN ' . ($upgraded ? 'upgraded' : 'downgraded') . ' prepare without quote - FAIL' . "\n";
        } else {
          $sth->bind_param(1, $bins, $binary_type);
          $sth->execute;
          my $fetch = $dbh->selectrow_array("SELECT b FROM t");
          print $driver . $desc . ' BIN ' . ($upgraded ? 'upgraded' : 'downgraded') . ' p+e with bind - insert: ' . ords($bins) . '; fetch: ' . ords($fetch) . ' - ' . ($bins eq $fetch ? 'OK' : 'FAIL') . "\n";
          my $hfetch = pack("H*", $dbh->selectrow_array("SELECT $hex_sql FROM t"));
          print $driver . $desc . ' BIN ' . ($upgraded ? 'upgraded' : 'downgraded') . ' p+e with bind - insert: ' . ords($bins) . '; hex fetch: ' . ords($hfetch) . ' - ' . ($bins eq $hfetch ? 'OK' : 'FAIL') . "\n";
        }
        $dbh->do("DROP TABLE t");
      }
      if ($driver !~ /^ODBC/) {
        $dbh->do("CREATE TABLE t(b $binary_sql)");
        $dbh->do("INSERT INTO t(b) VALUES(" . $dbh->quote($bins, $binary_type) . ")");
        my ($fetch) = $dbh->selectrow_array("SELECT b FROM t");
        print $driver . $desc . ' BIN ' . ($upgraded ? 'upgraded' : 'downgraded') . ' do without bind - insert: ' . ords($bins) . '; fetch: ' . ords($fetch) . ' - ' . ($bins eq $fetch ? 'OK' : 'FAIL') . "\n";
        my $hfetch = pack("H*", $dbh->selectrow_array("SELECT $hex_sql FROM t"));
        print $driver . $desc . ' BIN ' . ($upgraded ? 'upgraded' : 'downgraded') . ' do without bind - insert: ' . ords($bins) . '; hex fetch: ' . ords($hfetch) . ' - ' . ($bins eq $hfetch ? 'OK' : 'FAIL') . "\n";
        $dbh->do("DROP TABLE t");
      }
    }

    # Combined binary + Unicode
    for my $upgraded (0, 1) {
      $upgraded ? utf8::upgrade($bins) : utf8::downgrade($bins);
      if ($driver !~ /^ODBC/) {
        my $ins = $val;
        $dbh->do("CREATE TABLE t(s VARCHAR(10), b $binary_sql)");
        my $sth = $dbh->prepare("INSERT INTO t(s, b) VALUES(" . qq('$ins') . ", " . $dbh->quote($bins, $binary_type) . ")");
        if (not $sth) {
          print $driver . $desc . ' COMB ' . ($upgraded ? 'upgraded' : 'downgraded') . ' prepare with quote - FAIL' . "\n";
        } else {
          $sth->execute();
          my ($fetch, $bfetch) = $dbh->selectrow_array("SELECT s, b FROM t");
          print $driver . $desc . ' COMB ' . ($upgraded ? 'upgraded' : 'downgraded') . ' p+e without bind - insert: ' . ords($ins) . '; fetch: ' . ords($fetch) . ' - ' . ($ins eq $fetch ? 'OK' : 'FAIL') . "\n";
          print $driver . $desc . ' COMB BIN ' . ($upgraded ? 'upgraded' : 'downgraded') . ' p+e without bind - insert: ' . ords($bins) . '; fetch: ' . ords($bfetch) . ' - ' . ($bins eq $bfetch ? 'OK' : 'FAIL') . "\n";
          my $hfetch = pack("H*", $dbh->selectrow_array("SELECT $hex_sql FROM t"));
          print $driver . $desc . ' COMB BIN ' . ($upgraded ? 'upgraded' : 'downgraded') . ' p+e without bind - insert: ' . ords($bins) . '; hex fetch: ' . ords($hfetch) . ' - ' . ($bins eq $hfetch ? 'OK' : 'FAIL') . "\n";
        }
        $dbh->do("DROP TABLE t");
      }
      {
        my $ins = $val;
        $dbh->do("CREATE TABLE t(s VARCHAR(10), b $binary_sql)");
        my $sth = $dbh->prepare("INSERT INTO t(s, b) VALUES(?, ?)");
        if (not $sth) {
          print $driver . $desc . ' COMB ' . ($upgraded ? 'upgraded' : 'downgraded') . ' prepare without quote - FAIL' . "\n";
        } else {
          $sth->bind_param(1, $ins);
          $sth->bind_param(2, $bins, $binary_type);
          $sth->execute;
          my ($fetch, $bfetch) = $dbh->selectrow_array("SELECT s, b FROM t");
          print $driver . $desc . ' COMB ' . ($upgraded ? 'upgraded' : 'downgraded') . ' p+e with bind - insert: ' . ords($ins) . '; fetch: ' . ords($fetch) . ' - ' . ($ins eq $fetch ? 'OK' : 'FAIL') . "\n";
          print $driver . $desc . ' COMB BIN ' . ($upgraded ? 'upgraded' : 'downgraded') . ' p+e with bind - insert: ' . ords($bins) . '; fetch: ' . ords($bfetch) . ' - ' . ($bins eq $bfetch ? 'OK' : 'FAIL') . "\n";
          my $hfetch = pack("H*", $dbh->selectrow_array("SELECT $hex_sql FROM t"));
          print $driver . $desc . ' COMB BIN ' . ($upgraded ? 'upgraded' : 'downgraded') . ' p+e with bind - insert: ' . ords($bins) . '; hex fetch: ' . ords($hfetch) . ' - ' . ($bins eq $hfetch ? 'OK' : 'FAIL') . "\n";
        }
        $dbh->do("DROP TABLE t");
      }
      if ($driver !~ /^ODBC/) {
        my $ins = $val;
        $dbh->do("CREATE TABLE t(s VARCHAR(10), b $binary_sql)");
        $dbh->do("INSERT INTO t(s, b) VALUES(" . qq('$ins') . ", " . $dbh->quote($bins, $binary_type) . ")");
        my ($fetch, $bfetch) = $dbh->selectrow_array("SELECT s, b FROM t");
        print $driver . $desc . ' COMB ' . ($upgraded ? 'upgraded' : 'downgraded') . ' do without bind - insert: ' . ords($ins) . '; fetch: ' . ords($fetch) . ' - ' . ($ins eq $fetch ? 'OK' : 'FAIL') . "\n";
        print $driver . $desc . ' COMB BIN ' . ($upgraded ? 'upgraded' : 'downgraded') . ' do without bind - insert: ' . ords($bins) . '; fetch: ' . ords($bfetch) . ' - ' . ($bins eq $bfetch ? 'OK' : 'FAIL') . "\n";
        my $hfetch = pack("H*", $dbh->selectrow_array("SELECT $hex_sql FROM t"));
        print $driver . $desc . ' COMB BIN ' . ($upgraded ? 'upgraded' : 'downgraded') . ' do without bind - insert: ' . ords($bins) . '; hex fetch: ' . ords($hfetch) . ' - ' . ($bins eq $hfetch ? 'OK' : 'FAIL') . "\n";
        $dbh->do("DROP TABLE t");
      }
    }

    # Pg COPY DATA
    if ($driver eq 'Pg') {
      {
        my $ins = $val;
        $dbh->do("CREATE TABLE t(s VARCHAR(10))");
        $dbh->do("INSERT INTO t(s) VALUES(?)", undef, $ins);
        $dbh->do("COPY t TO STDOUT");
        my @data; my $i = 0;
        1 while $dbh->pg_getcopydata(\$data[$i++]) >= 0;
        my ($fetch) = ($data[0] =~ /^(.*)\n$/);
        print 'Pg COPY TO STDOUT: ' . ords($ins) . '; fetch: ' . ords($fetch) . ' - ' . ($ins eq $fetch ? 'OK' : 'FAIL') . "\n";
        $dbh->do("DROP TABLE t");
      }

      {
        my $ins = $val;
        $dbh->do("CREATE TABLE t(s VARCHAR(10))");
        $dbh->do("COPY t FROM STDIN");
        $dbh->pg_putcopydata($ins);
        $dbh->pg_putcopyend();
        my $fetch = $dbh->selectrow_array("SELECT s FROM t");
        print 'Pg COPY FROM STDIN: ' . ords($ins) . '; fetch: ' . ords($fetch) . ' - ' . ($ins eq $fetch ? 'OK' : 'FAIL') . "\n";
        $dbh->do("DROP TABLE t");
      }

      {
        my $ins = $val;
        $dbh->do("CREATE TABLE t(s VARCHAR(10))");
        $dbh->do("COPY t FROM STDIN");
        $dbh->pg_putcopydata($ins);
        $dbh->pg_putcopyend();
        $dbh->do("COPY t TO STDOUT");
        my @data; my $i = 0;
        1 while $dbh->pg_getcopydata(\$data[$i++]) >= 0;
        my ($fetch) = ($data[0] =~ /^(.*)\n$/);
        print 'Pg COPY FROM STDIN + COPY TO STDOUT: ' . ords($ins) . '; fetch: ' . ords($fetch) . ' - ' . ($ins eq $fetch ? 'OK' : 'FAIL') . "\n";
        $dbh->do("DROP TABLE t");
      }

      for my $upgraded (0, 1) {
        $upgraded ? utf8::upgrade($bins) : utf8::downgrade($bins);
        {
          $dbh->do("CREATE TABLE t(b $binary_sql)");
          my $sth = $dbh->prepare("INSERT INTO t(b) VALUES(?)");
          $sth->bind_param(1, $bins, $binary_type);
          $sth->execute;
          $dbh->do("COPY t TO STDOUT (FORMAT BINARY)");
          my @data; my $i = 0;
          1 while $dbh->pg_getcopydata(\$data[$i++]) >= 0;
          my ($fetch) = ($data[0] =~ /^PGCOPY\n\xff\r\n\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01....(.*)$/s);
          print 'Pg COPY TO STDOUT BINARY: ' . ($upgraded ? 'upgraded' : 'downgraded') . ': ' . ords($bins) . '; fetch: ' . ords($fetch) . ' - ' . ($bins eq $fetch ? 'OK' : 'FAIL') . "\n";
          $dbh->do("DROP TABLE t");
        }

        {
          $dbh->do("CREATE TABLE t(b $binary_sql)");
          $dbh->do("COPY t FROM STDIN (FORMAT BINARY)");
          $dbh->pg_putcopydata("PGCOPY\n\xff\r\n\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01" . pack('N', length($bins)) . $bins);
          $dbh->pg_putcopydata("\xff\xff");
          $dbh->pg_putcopyend();
          my $fetch = $dbh->selectrow_array("SELECT b FROM t");
          print 'Pg COPY FROM STDIN BINARY ' . ($upgraded ? 'upgraded' : 'downgraded') . ': ' . ords($bins) . '; fetch: ' . ords($fetch) . ' - ' . ($bins eq $fetch ? 'OK' : 'FAIL') . "\n";
          $dbh->do("DROP TABLE t");
        }
      }
    }
  }
}

Output on our RHEL7 box:

Pg p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
Pg do without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg do with bind - insert: (195, 161); fetch: (195, 161) - OK
Pg BIN downgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg BIN downgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg BIN downgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg BIN downgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg BIN upgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg BIN upgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg BIN upgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg BIN upgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg COMB downgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN downgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COMB BIN downgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg COMB downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg COMB downgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN downgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COMB BIN downgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg COMB upgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN upgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COMB BIN upgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg COMB upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg COMB upgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN upgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COMB BIN upgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg COPY TO STDOUT: (195, 161); fetch: (195, 161) - OK
Pg COPY FROM STDIN: (195, 161); fetch: (195, 161) - OK
Pg COPY FROM STDIN + COPY TO STDOUT: (195, 161); fetch: (195, 161) - OK
Pg COPY TO STDOUT BINARY: downgraded: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COPY FROM STDIN BINARY downgraded: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COPY TO STDOUT BINARY: upgraded: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COPY FROM STDIN BINARY upgraded: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
Pg do without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg do with bind - insert: (195, 161); fetch: (195, 161) - OK
Pg BIN downgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg BIN downgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg BIN downgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg BIN downgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg BIN upgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg BIN upgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg BIN upgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg BIN upgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg COMB downgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN downgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COMB BIN downgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg COMB downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg COMB downgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN downgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COMB BIN downgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg COMB upgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN upgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COMB BIN upgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg COMB upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg COMB upgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN upgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COMB BIN upgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
Pg COPY TO STDOUT: (195, 161); fetch: (195, 161) - OK
Pg COPY FROM STDIN: (195, 161); fetch: (195, 161) - OK
Pg COPY FROM STDIN + COPY TO STDOUT: (195, 161); fetch: (195, 161) - OK
Pg COPY TO STDOUT BINARY: downgraded: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COPY FROM STDIN BINARY downgraded: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COPY TO STDOUT BINARY: upgraded: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg COPY FROM STDIN BINARY upgraded: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
Pg p+e without bind - insert: (225); fetch: (225) - OK
Pg p+e with bind - insert: (225); fetch: (225) - OK
Pg do without bind - insert: (225); fetch: (225) - OK
Pg do with bind - insert: (225); fetch: (225) - OK
Pg BIN downgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg BIN downgraded p+e without bind - insert: (195, 161); hex fetch: (195, 161) - OK
Pg BIN downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
Pg BIN downgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
Pg BIN downgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg BIN downgraded do without bind - insert: (195, 161); hex fetch: (195, 161) - OK
Pg BIN upgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg BIN upgraded p+e without bind - insert: (195, 161); hex fetch: (195, 161) - OK
Pg BIN upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
Pg BIN upgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
Pg BIN upgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg BIN upgraded do without bind - insert: (195, 161); hex fetch: (195, 161) - OK
Pg COMB downgraded p+e without bind - insert: (225); fetch: (225) - OK
Pg COMB BIN downgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN downgraded p+e without bind - insert: (195, 161); hex fetch: (195, 161) - OK
Pg COMB downgraded p+e with bind - insert: (225); fetch: (225) - OK
Pg COMB BIN downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN downgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
Pg COMB downgraded do without bind - insert: (225); fetch: (225) - OK
Pg COMB BIN downgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN downgraded do without bind - insert: (195, 161); hex fetch: (195, 161) - OK
Pg COMB upgraded p+e without bind - insert: (225); fetch: (225) - OK
Pg COMB BIN upgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN upgraded p+e without bind - insert: (195, 161); hex fetch: (195, 161) - OK
Pg COMB upgraded p+e with bind - insert: (225); fetch: (225) - OK
Pg COMB BIN upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN upgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
Pg COMB upgraded do without bind - insert: (225); fetch: (225) - OK
Pg COMB BIN upgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
Pg COMB BIN upgraded do without bind - insert: (195, 161); hex fetch: (195, 161) - OK
Pg COPY TO STDOUT: (225); fetch: (225) - OK
Pg COPY FROM STDIN: (225); fetch: (225) - OK
Pg COPY FROM STDIN + COPY TO STDOUT: (225); fetch: (225) - OK
Pg COPY TO STDOUT BINARY: downgraded: (195, 161); fetch: (195, 161) - OK
Pg COPY FROM STDIN BINARY downgraded: (195, 161); fetch: (195, 161) - OK
Pg COPY TO STDOUT BINARY: upgraded: (195, 161); fetch: (195, 161) - OK
Pg COPY FROM STDIN BINARY upgraded: (195, 161); fetch: (195, 161) - OK
Pg p+e without bind - insert: (269); fetch: (269) - OK
Pg p+e with bind - insert: (269); fetch: (269) - OK
Pg do without bind - insert: (269); fetch: (269) - OK
Pg do with bind - insert: (269); fetch: (269) - OK
Pg BIN downgraded p+e without bind - insert: (196, 141); fetch: (196, 141) - OK
Pg BIN downgraded p+e without bind - insert: (196, 141); hex fetch: (196, 141) - OK
Pg BIN downgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
Pg BIN downgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
Pg BIN downgraded do without bind - insert: (196, 141); fetch: (196, 141) - OK
Pg BIN downgraded do without bind - insert: (196, 141); hex fetch: (196, 141) - OK
Pg BIN upgraded p+e without bind - insert: (196, 141); fetch: (196, 141) - OK
Pg BIN upgraded p+e without bind - insert: (196, 141); hex fetch: (196, 141) - OK
Pg BIN upgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
Pg BIN upgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
Pg BIN upgraded do without bind - insert: (196, 141); fetch: (196, 141) - OK
Pg BIN upgraded do without bind - insert: (196, 141); hex fetch: (196, 141) - OK
Pg COMB downgraded p+e without bind - insert: (269); fetch: (269) - OK
Pg COMB BIN downgraded p+e without bind - insert: (196, 141); fetch: (196, 141) - OK
Pg COMB BIN downgraded p+e without bind - insert: (196, 141); hex fetch: (196, 141) - OK
Pg COMB downgraded p+e with bind - insert: (269); fetch: (269) - OK
Pg COMB BIN downgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
Pg COMB BIN downgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
Pg COMB downgraded do without bind - insert: (269); fetch: (269) - OK
Pg COMB BIN downgraded do without bind - insert: (196, 141); fetch: (196, 141) - OK
Pg COMB BIN downgraded do without bind - insert: (196, 141); hex fetch: (196, 141) - OK
Pg COMB upgraded p+e without bind - insert: (269); fetch: (269) - OK
Pg COMB BIN upgraded p+e without bind - insert: (196, 141); fetch: (196, 141) - OK
Pg COMB BIN upgraded p+e without bind - insert: (196, 141); hex fetch: (196, 141) - OK
Pg COMB upgraded p+e with bind - insert: (269); fetch: (269) - OK
Pg COMB BIN upgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
Pg COMB BIN upgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
Pg COMB upgraded do without bind - insert: (269); fetch: (269) - OK
Pg COMB BIN upgraded do without bind - insert: (196, 141); fetch: (196, 141) - OK
Pg COMB BIN upgraded do without bind - insert: (196, 141); hex fetch: (196, 141) - OK
Pg COPY TO STDOUT: (269); fetch: (269) - OK
Pg COPY FROM STDIN: (269); fetch: (269) - OK
Pg COPY FROM STDIN + COPY TO STDOUT: (269); fetch: (269) - OK
Pg COPY TO STDOUT BINARY: downgraded: (196, 141); fetch: (196, 141) - OK
Pg COPY FROM STDIN BINARY downgraded: (196, 141); fetch: (196, 141) - OK
Pg COPY TO STDOUT BINARY: upgraded: (196, 141); fetch: (196, 141) - OK
Pg COPY FROM STDIN BINARY upgraded: (196, 141); fetch: (196, 141) - OK
Pg p+e without bind - insert: (9786); fetch: (9786) - OK
Pg p+e with bind - insert: (9786); fetch: (9786) - OK
Pg do without bind - insert: (9786); fetch: (9786) - OK
Pg do with bind - insert: (9786); fetch: (9786) - OK
Pg BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB downgraded p+e without bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB downgraded p+e with bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB downgraded do without bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB upgraded p+e without bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB upgraded p+e with bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB upgraded do without bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COPY TO STDOUT: (9786); fetch: (9786) - OK
Pg COPY FROM STDIN: (9786); fetch: (9786) - OK
Pg COPY FROM STDIN + COPY TO STDOUT: (9786); fetch: (9786) - OK
Pg COPY TO STDOUT BINARY: downgraded: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COPY FROM STDIN BINARY downgraded: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COPY TO STDOUT BINARY: upgraded: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COPY FROM STDIN BINARY upgraded: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg p+e without bind - insert: (9786); fetch: (9786) - OK
Pg p+e with bind - insert: (9786); fetch: (9786) - OK
Pg do without bind - insert: (9786); fetch: (9786) - OK
Pg do with bind - insert: (9786); fetch: (9786) - OK
Pg BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB downgraded p+e without bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB downgraded p+e with bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB downgraded do without bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB upgraded p+e without bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB upgraded p+e with bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB upgraded do without bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COPY TO STDOUT: (9786); fetch: (9786) - OK
Pg COPY FROM STDIN: (9786); fetch: (9786) - OK
Pg COPY FROM STDIN + COPY TO STDOUT: (9786); fetch: (9786) - OK
Pg COPY TO STDOUT BINARY: downgraded: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COPY FROM STDIN BINARY downgraded: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COPY TO STDOUT BINARY: upgraded: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COPY FROM STDIN BINARY upgraded: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg p+e without bind - insert: (9786); fetch: (9786) - OK
Pg p+e with bind - insert: (9786); fetch: (9786) - OK
Pg do without bind - insert: (9786); fetch: (9786) - OK
Pg do with bind - insert: (9786); fetch: (9786) - OK
Pg BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB downgraded p+e without bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB downgraded p+e with bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB downgraded do without bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB upgraded p+e without bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB upgraded p+e with bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COMB upgraded do without bind - insert: (9786); fetch: (9786) - OK
Pg COMB BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COMB BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
Pg COPY TO STDOUT: (9786); fetch: (9786) - OK
Pg COPY FROM STDIN: (9786); fetch: (9786) - OK
Pg COPY FROM STDIN + COPY TO STDOUT: (9786); fetch: (9786) - OK
Pg COPY TO STDOUT BINARY: downgraded: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COPY FROM STDIN BINARY downgraded: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COPY TO STDOUT BINARY: upgraded: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg COPY FROM STDIN BINARY upgraded: (226, 152, 186); fetch: (226, 152, 186) - OK
Pg p+e without bind - insert: (69905); fetch: (69905) - OK
Pg p+e with bind - insert: (69905); fetch: (69905) - OK
Pg do without bind - insert: (69905); fetch: (69905) - OK
Pg do with bind - insert: (69905); fetch: (69905) - OK
Pg BIN downgraded p+e without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
Pg BIN downgraded p+e without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
Pg BIN downgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
Pg BIN downgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
Pg BIN downgraded do without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
Pg BIN downgraded do without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
Pg BIN upgraded p+e without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
Pg BIN upgraded p+e without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
Pg BIN upgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
Pg BIN upgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
Pg BIN upgraded do without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
Pg BIN upgraded do without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
Pg COMB downgraded p+e without bind - insert: (69905); fetch: (69905) - OK
Pg COMB BIN downgraded p+e without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
Pg COMB BIN downgraded p+e without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
Pg COMB downgraded p+e with bind - insert: (69905); fetch: (69905) - OK
Pg COMB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
Pg COMB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
Pg COMB downgraded do without bind - insert: (69905); fetch: (69905) - OK
Pg COMB BIN downgraded do without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
Pg COMB BIN downgraded do without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
Pg COMB upgraded p+e without bind - insert: (69905); fetch: (69905) - OK
Pg COMB BIN upgraded p+e without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
Pg COMB BIN upgraded p+e without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
Pg COMB upgraded p+e with bind - insert: (69905); fetch: (69905) - OK
Pg COMB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
Pg COMB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
Pg COMB upgraded do without bind - insert: (69905); fetch: (69905) - OK
Pg COMB BIN upgraded do without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
Pg COMB BIN upgraded do without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
Pg COPY TO STDOUT: (69905); fetch: (69905) - OK
Pg COPY FROM STDIN: (69905); fetch: (69905) - OK
Pg COPY FROM STDIN + COPY TO STDOUT: (69905); fetch: (69905) - OK
Pg COPY TO STDOUT BINARY: downgraded: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
Pg COPY FROM STDIN BINARY downgraded: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
Pg COPY TO STDOUT BINARY: upgraded: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
Pg COPY FROM STDIN BINARY upgraded: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
MariaDB p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB do without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB do with bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB BIN downgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB BIN downgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB BIN downgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB BIN downgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB BIN upgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB BIN upgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB BIN upgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB BIN upgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB COMB downgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN downgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB COMB BIN downgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB COMB downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB COMB downgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN downgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB COMB BIN downgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB COMB upgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN upgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB COMB BIN upgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB COMB upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB COMB upgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN upgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB COMB BIN upgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB do without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB do with bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB BIN downgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB BIN downgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB BIN downgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB BIN downgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB BIN upgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB BIN upgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB BIN upgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB BIN upgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB COMB downgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN downgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB COMB BIN downgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB COMB downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB COMB downgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN downgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB COMB BIN downgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB COMB upgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN upgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB COMB BIN upgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB COMB upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB COMB upgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN upgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
MariaDB COMB BIN upgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
MariaDB p+e without bind - insert: (225); fetch: (225) - OK
MariaDB p+e with bind - insert: (225); fetch: (225) - OK
MariaDB do without bind - insert: (225); fetch: (225) - OK
MariaDB do with bind - insert: (225); fetch: (225) - OK
MariaDB BIN downgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB BIN downgraded p+e without bind - insert: (195, 161); hex fetch: (195, 161) - OK
MariaDB BIN downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB BIN downgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
MariaDB BIN downgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB BIN downgraded do without bind - insert: (195, 161); hex fetch: (195, 161) - OK
MariaDB BIN upgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB BIN upgraded p+e without bind - insert: (195, 161); hex fetch: (195, 161) - OK
MariaDB BIN upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB BIN upgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
MariaDB BIN upgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB BIN upgraded do without bind - insert: (195, 161); hex fetch: (195, 161) - OK
MariaDB COMB downgraded p+e without bind - insert: (225); fetch: (225) - OK
MariaDB COMB BIN downgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN downgraded p+e without bind - insert: (195, 161); hex fetch: (195, 161) - OK
MariaDB COMB downgraded p+e with bind - insert: (225); fetch: (225) - OK
MariaDB COMB BIN downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN downgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
MariaDB COMB downgraded do without bind - insert: (225); fetch: (225) - OK
MariaDB COMB BIN downgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN downgraded do without bind - insert: (195, 161); hex fetch: (195, 161) - OK
MariaDB COMB upgraded p+e without bind - insert: (225); fetch: (225) - OK
MariaDB COMB BIN upgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN upgraded p+e without bind - insert: (195, 161); hex fetch: (195, 161) - OK
MariaDB COMB upgraded p+e with bind - insert: (225); fetch: (225) - OK
MariaDB COMB BIN upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN upgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
MariaDB COMB upgraded do without bind - insert: (225); fetch: (225) - OK
MariaDB COMB BIN upgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
MariaDB COMB BIN upgraded do without bind - insert: (195, 161); hex fetch: (195, 161) - OK
MariaDB p+e without bind - insert: (269); fetch: (269) - OK
MariaDB p+e with bind - insert: (269); fetch: (269) - OK
MariaDB do without bind - insert: (269); fetch: (269) - OK
MariaDB do with bind - insert: (269); fetch: (269) - OK
MariaDB BIN downgraded p+e without bind - insert: (196, 141); fetch: (196, 141) - OK
MariaDB BIN downgraded p+e without bind - insert: (196, 141); hex fetch: (196, 141) - OK
MariaDB BIN downgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
MariaDB BIN downgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
MariaDB BIN downgraded do without bind - insert: (196, 141); fetch: (196, 141) - OK
MariaDB BIN downgraded do without bind - insert: (196, 141); hex fetch: (196, 141) - OK
MariaDB BIN upgraded p+e without bind - insert: (196, 141); fetch: (196, 141) - OK
MariaDB BIN upgraded p+e without bind - insert: (196, 141); hex fetch: (196, 141) - OK
MariaDB BIN upgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
MariaDB BIN upgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
MariaDB BIN upgraded do without bind - insert: (196, 141); fetch: (196, 141) - OK
MariaDB BIN upgraded do without bind - insert: (196, 141); hex fetch: (196, 141) - OK
MariaDB COMB downgraded p+e without bind - insert: (269); fetch: (269) - OK
MariaDB COMB BIN downgraded p+e without bind - insert: (196, 141); fetch: (196, 141) - OK
MariaDB COMB BIN downgraded p+e without bind - insert: (196, 141); hex fetch: (196, 141) - OK
MariaDB COMB downgraded p+e with bind - insert: (269); fetch: (269) - OK
MariaDB COMB BIN downgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
MariaDB COMB BIN downgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
MariaDB COMB downgraded do without bind - insert: (269); fetch: (269) - OK
MariaDB COMB BIN downgraded do without bind - insert: (196, 141); fetch: (196, 141) - OK
MariaDB COMB BIN downgraded do without bind - insert: (196, 141); hex fetch: (196, 141) - OK
MariaDB COMB upgraded p+e without bind - insert: (269); fetch: (269) - OK
MariaDB COMB BIN upgraded p+e without bind - insert: (196, 141); fetch: (196, 141) - OK
MariaDB COMB BIN upgraded p+e without bind - insert: (196, 141); hex fetch: (196, 141) - OK
MariaDB COMB upgraded p+e with bind - insert: (269); fetch: (269) - OK
MariaDB COMB BIN upgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
MariaDB COMB BIN upgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
MariaDB COMB upgraded do without bind - insert: (269); fetch: (269) - OK
MariaDB COMB BIN upgraded do without bind - insert: (196, 141); fetch: (196, 141) - OK
MariaDB COMB BIN upgraded do without bind - insert: (196, 141); hex fetch: (196, 141) - OK
MariaDB p+e without bind - insert: (9786); fetch: (9786) - OK
MariaDB p+e with bind - insert: (9786); fetch: (9786) - OK
MariaDB do without bind - insert: (9786); fetch: (9786) - OK
MariaDB do with bind - insert: (9786); fetch: (9786) - OK
MariaDB BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB downgraded p+e without bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB downgraded p+e with bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB downgraded do without bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB upgraded p+e without bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB upgraded p+e with bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB upgraded do without bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB p+e without bind - insert: (9786); fetch: (9786) - OK
MariaDB p+e with bind - insert: (9786); fetch: (9786) - OK
MariaDB do without bind - insert: (9786); fetch: (9786) - OK
MariaDB do with bind - insert: (9786); fetch: (9786) - OK
MariaDB BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB downgraded p+e without bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB downgraded p+e with bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB downgraded do without bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB upgraded p+e without bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB upgraded p+e with bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB upgraded do without bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB p+e without bind - insert: (9786); fetch: (9786) - OK
MariaDB p+e with bind - insert: (9786); fetch: (9786) - OK
MariaDB do without bind - insert: (9786); fetch: (9786) - OK
MariaDB do with bind - insert: (9786); fetch: (9786) - OK
MariaDB BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB downgraded p+e without bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB downgraded p+e with bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB downgraded do without bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB upgraded p+e without bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB upgraded p+e with bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB COMB upgraded do without bind - insert: (9786); fetch: (9786) - OK
MariaDB COMB BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
MariaDB COMB BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
MariaDB p+e without bind - insert: (69905); fetch: (69905) - OK
MariaDB p+e with bind - insert: (69905); fetch: (69905) - OK
MariaDB do without bind - insert: (69905); fetch: (69905) - OK
MariaDB do with bind - insert: (69905); fetch: (69905) - OK
MariaDB BIN downgraded p+e without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
MariaDB BIN downgraded p+e without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
MariaDB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
MariaDB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
MariaDB BIN downgraded do without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
MariaDB BIN downgraded do without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
MariaDB BIN upgraded p+e without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
MariaDB BIN upgraded p+e without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
MariaDB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
MariaDB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
MariaDB BIN upgraded do without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
MariaDB BIN upgraded do without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
MariaDB COMB downgraded p+e without bind - insert: (69905); fetch: (69905) - OK
MariaDB COMB BIN downgraded p+e without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
MariaDB COMB BIN downgraded p+e without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
MariaDB COMB downgraded p+e with bind - insert: (69905); fetch: (69905) - OK
MariaDB COMB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
MariaDB COMB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
MariaDB COMB downgraded do without bind - insert: (69905); fetch: (69905) - OK
MariaDB COMB BIN downgraded do without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
MariaDB COMB BIN downgraded do without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
MariaDB COMB upgraded p+e without bind - insert: (69905); fetch: (69905) - OK
MariaDB COMB BIN upgraded p+e without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
MariaDB COMB BIN upgraded p+e without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
MariaDB COMB upgraded p+e with bind - insert: (69905); fetch: (69905) - OK
MariaDB COMB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
MariaDB COMB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
MariaDB COMB upgraded do without bind - insert: (69905); fetch: (69905) - OK
MariaDB COMB BIN upgraded do without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
MariaDB COMB BIN upgraded do without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
SQLite p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite do without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite do with bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite BIN downgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite BIN downgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite BIN downgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite BIN downgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite BIN upgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite BIN upgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite BIN upgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite BIN upgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite COMB downgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN downgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite COMB BIN downgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite COMB downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite COMB downgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN downgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite COMB BIN downgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite COMB upgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN upgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite COMB BIN upgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite COMB upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite COMB upgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN upgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite COMB BIN upgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite do without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite do with bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite BIN downgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite BIN downgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite BIN downgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite BIN downgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite BIN upgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite BIN upgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite BIN upgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite BIN upgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite COMB downgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN downgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite COMB BIN downgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite COMB downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite COMB downgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN downgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite COMB BIN downgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite COMB upgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN upgraded p+e without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite COMB BIN upgraded p+e without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite COMB upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite COMB upgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN upgraded do without bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
SQLite COMB BIN upgraded do without bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
SQLite p+e without bind - insert: (225); fetch: (225) - OK
SQLite p+e with bind - insert: (225); fetch: (225) - OK
SQLite do without bind - insert: (225); fetch: (225) - OK
SQLite do with bind - insert: (225); fetch: (225) - OK
SQLite BIN downgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite BIN downgraded p+e without bind - insert: (195, 161); hex fetch: (195, 161) - OK
SQLite BIN downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite BIN downgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
SQLite BIN downgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite BIN downgraded do without bind - insert: (195, 161); hex fetch: (195, 161) - OK
SQLite BIN upgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite BIN upgraded p+e without bind - insert: (195, 161); hex fetch: (195, 161) - OK
SQLite BIN upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite BIN upgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
SQLite BIN upgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite BIN upgraded do without bind - insert: (195, 161); hex fetch: (195, 161) - OK
SQLite COMB downgraded p+e without bind - insert: (225); fetch: (225) - OK
SQLite COMB BIN downgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN downgraded p+e without bind - insert: (195, 161); hex fetch: (195, 161) - OK
SQLite COMB downgraded p+e with bind - insert: (225); fetch: (225) - OK
SQLite COMB BIN downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN downgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
SQLite COMB downgraded do without bind - insert: (225); fetch: (225) - OK
SQLite COMB BIN downgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN downgraded do without bind - insert: (195, 161); hex fetch: (195, 161) - OK
SQLite COMB upgraded p+e without bind - insert: (225); fetch: (225) - OK
SQLite COMB BIN upgraded p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN upgraded p+e without bind - insert: (195, 161); hex fetch: (195, 161) - OK
SQLite COMB upgraded p+e with bind - insert: (225); fetch: (225) - OK
SQLite COMB BIN upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN upgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
SQLite COMB upgraded do without bind - insert: (225); fetch: (225) - OK
SQLite COMB BIN upgraded do without bind - insert: (195, 161); fetch: (195, 161) - OK
SQLite COMB BIN upgraded do without bind - insert: (195, 161); hex fetch: (195, 161) - OK
SQLite p+e without bind - insert: (269); fetch: (269) - OK
SQLite p+e with bind - insert: (269); fetch: (269) - OK
SQLite do without bind - insert: (269); fetch: (269) - OK
SQLite do with bind - insert: (269); fetch: (269) - OK
SQLite BIN downgraded p+e without bind - insert: (196, 141); fetch: (196, 141) - OK
SQLite BIN downgraded p+e without bind - insert: (196, 141); hex fetch: (196, 141) - OK
SQLite BIN downgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
SQLite BIN downgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
SQLite BIN downgraded do without bind - insert: (196, 141); fetch: (196, 141) - OK
SQLite BIN downgraded do without bind - insert: (196, 141); hex fetch: (196, 141) - OK
SQLite BIN upgraded p+e without bind - insert: (196, 141); fetch: (196, 141) - OK
SQLite BIN upgraded p+e without bind - insert: (196, 141); hex fetch: (196, 141) - OK
SQLite BIN upgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
SQLite BIN upgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
SQLite BIN upgraded do without bind - insert: (196, 141); fetch: (196, 141) - OK
SQLite BIN upgraded do without bind - insert: (196, 141); hex fetch: (196, 141) - OK
SQLite COMB downgraded p+e without bind - insert: (269); fetch: (269) - OK
SQLite COMB BIN downgraded p+e without bind - insert: (196, 141); fetch: (196, 141) - OK
SQLite COMB BIN downgraded p+e without bind - insert: (196, 141); hex fetch: (196, 141) - OK
SQLite COMB downgraded p+e with bind - insert: (269); fetch: (269) - OK
SQLite COMB BIN downgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
SQLite COMB BIN downgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
SQLite COMB downgraded do without bind - insert: (269); fetch: (269) - OK
SQLite COMB BIN downgraded do without bind - insert: (196, 141); fetch: (196, 141) - OK
SQLite COMB BIN downgraded do without bind - insert: (196, 141); hex fetch: (196, 141) - OK
SQLite COMB upgraded p+e without bind - insert: (269); fetch: (269) - OK
SQLite COMB BIN upgraded p+e without bind - insert: (196, 141); fetch: (196, 141) - OK
SQLite COMB BIN upgraded p+e without bind - insert: (196, 141); hex fetch: (196, 141) - OK
SQLite COMB upgraded p+e with bind - insert: (269); fetch: (269) - OK
SQLite COMB BIN upgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
SQLite COMB BIN upgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
SQLite COMB upgraded do without bind - insert: (269); fetch: (269) - OK
SQLite COMB BIN upgraded do without bind - insert: (196, 141); fetch: (196, 141) - OK
SQLite COMB BIN upgraded do without bind - insert: (196, 141); hex fetch: (196, 141) - OK
SQLite p+e without bind - insert: (9786); fetch: (9786) - OK
SQLite p+e with bind - insert: (9786); fetch: (9786) - OK
SQLite do without bind - insert: (9786); fetch: (9786) - OK
SQLite do with bind - insert: (9786); fetch: (9786) - OK
SQLite BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB downgraded p+e without bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB downgraded p+e with bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB downgraded do without bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB upgraded p+e without bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB upgraded p+e with bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB upgraded do without bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite p+e without bind - insert: (9786); fetch: (9786) - OK
SQLite p+e with bind - insert: (9786); fetch: (9786) - OK
SQLite do without bind - insert: (9786); fetch: (9786) - OK
SQLite do with bind - insert: (9786); fetch: (9786) - OK
SQLite BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB downgraded p+e without bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB downgraded p+e with bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB downgraded do without bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB upgraded p+e without bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB upgraded p+e with bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB upgraded do without bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite p+e without bind - insert: (9786); fetch: (9786) - OK
SQLite p+e with bind - insert: (9786); fetch: (9786) - OK
SQLite do without bind - insert: (9786); fetch: (9786) - OK
SQLite do with bind - insert: (9786); fetch: (9786) - OK
SQLite BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB downgraded p+e without bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN downgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN downgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB downgraded p+e with bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB downgraded do without bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN downgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN downgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB upgraded p+e without bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN upgraded p+e without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN upgraded p+e without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB upgraded p+e with bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite COMB upgraded do without bind - insert: (9786); fetch: (9786) - OK
SQLite COMB BIN upgraded do without bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
SQLite COMB BIN upgraded do without bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
SQLite p+e without bind - insert: (69905); fetch: (69905) - OK
SQLite p+e with bind - insert: (69905); fetch: (69905) - OK
SQLite do without bind - insert: (69905); fetch: (69905) - OK
SQLite do with bind - insert: (69905); fetch: (69905) - OK
SQLite BIN downgraded p+e without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
SQLite BIN downgraded p+e without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
SQLite BIN downgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
SQLite BIN downgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
SQLite BIN downgraded do without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
SQLite BIN downgraded do without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
SQLite BIN upgraded p+e without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
SQLite BIN upgraded p+e without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
SQLite BIN upgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
SQLite BIN upgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
SQLite BIN upgraded do without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
SQLite BIN upgraded do without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
SQLite COMB downgraded p+e without bind - insert: (69905); fetch: (69905) - OK
SQLite COMB BIN downgraded p+e without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
SQLite COMB BIN downgraded p+e without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
SQLite COMB downgraded p+e with bind - insert: (69905); fetch: (69905) - OK
SQLite COMB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
SQLite COMB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
SQLite COMB downgraded do without bind - insert: (69905); fetch: (69905) - OK
SQLite COMB BIN downgraded do without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
SQLite COMB BIN downgraded do without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
SQLite COMB upgraded p+e without bind - insert: (69905); fetch: (69905) - OK
SQLite COMB BIN upgraded p+e without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
SQLite COMB BIN upgraded p+e without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
SQLite COMB upgraded p+e with bind - insert: (69905); fetch: (69905) - OK
SQLite COMB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
SQLite COMB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
SQLite COMB upgraded do without bind - insert: (69905); fetch: (69905) - OK
SQLite COMB BIN upgraded do without bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
SQLite COMB BIN upgraded do without bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
ODBC MySQL mode=ANSI p+e without bind - insert: (195, 161); fetch: (225) - FAIL
ODBC MySQL mode=ANSI p+e with bind - insert: (195, 161); fetch: (225) - FAIL
ODBC MySQL mode=ANSI do without bind - insert: (195, 161); fetch: (225) - FAIL
ODBC MySQL mode=ANSI do with bind - insert: (195, 161); fetch: (225) - FAIL
ODBC MySQL mode=ANSI BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
ODBC MySQL mode=ANSI BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
ODBC MySQL mode=ANSI BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC MySQL mode=ANSI BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC MySQL mode=ANSI COMB downgraded p+e with bind - insert: (195, 161); fetch: (225) - FAIL
ODBC MySQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
ODBC MySQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
ODBC MySQL mode=ANSI COMB upgraded p+e with bind - insert: (195, 161); fetch: (225) - FAIL
ODBC MySQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC MySQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC MySQL mode=ANSI p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC MySQL mode=ANSI p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC MySQL mode=ANSI do without bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC MySQL mode=ANSI do with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC MySQL mode=ANSI BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
ODBC MySQL mode=ANSI BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
ODBC MySQL mode=ANSI BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC MySQL mode=ANSI BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC MySQL mode=ANSI COMB downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC MySQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
ODBC MySQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
ODBC MySQL mode=ANSI COMB upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC MySQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC MySQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC MySQL mode=ANSI p+e without bind - insert: (225); fetch: (225) - OK
ODBC MySQL mode=ANSI p+e with bind - insert: (225); fetch: (225) - OK
ODBC MySQL mode=ANSI do without bind - insert: (225); fetch: (225) - OK
ODBC MySQL mode=ANSI do with bind - insert: (225); fetch: (225) - OK
ODBC MySQL mode=ANSI BIN downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC MySQL mode=ANSI BIN downgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
ODBC MySQL mode=ANSI BIN upgraded p+e with bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC MySQL mode=ANSI BIN upgraded p+e with bind - insert: (195, 161); hex fetch: (195, 131, 194, 161) - FAIL
ODBC MySQL mode=ANSI COMB downgraded p+e with bind - insert: (225); fetch: (225) - OK
ODBC MySQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC MySQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
ODBC MySQL mode=ANSI COMB upgraded p+e with bind - insert: (225); fetch: (225) - OK
ODBC MySQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC MySQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 161); hex fetch: (195, 131, 194, 161) - FAIL
ODBC MySQL mode=ANSI p+e without bind - insert: (269); fetch: (63) - FAIL
ODBC MySQL mode=ANSI p+e with bind - insert: (269); fetch: (63) - FAIL
ODBC MySQL mode=ANSI do without bind - insert: (269); fetch: (63) - FAIL
ODBC MySQL mode=ANSI do with bind - insert: (269); fetch: (63) - FAIL
ODBC MySQL mode=ANSI BIN downgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
ODBC MySQL mode=ANSI BIN downgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
ODBC MySQL mode=ANSI BIN upgraded p+e with bind - insert: (196, 141); fetch: (195, 132, 194, 141) - FAIL
ODBC MySQL mode=ANSI BIN upgraded p+e with bind - insert: (196, 141); hex fetch: (195, 132, 194, 141) - FAIL
ODBC MySQL mode=ANSI COMB downgraded p+e with bind - insert: (269); fetch: (63) - FAIL
ODBC MySQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
ODBC MySQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
ODBC MySQL mode=ANSI COMB upgraded p+e with bind - insert: (269); fetch: (63) - FAIL
ODBC MySQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (196, 141); fetch: (195, 132, 194, 141) - FAIL
ODBC MySQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (196, 141); hex fetch: (195, 132, 194, 141) - FAIL
ODBC MySQL mode=ANSI p+e without bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI p+e with bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI do without bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI do with bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC MySQL mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC MySQL mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC MySQL mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC MySQL mode=ANSI COMB downgraded p+e with bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC MySQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC MySQL mode=ANSI COMB upgraded p+e with bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC MySQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC MySQL mode=ANSI p+e without bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI p+e with bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI do without bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI do with bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC MySQL mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC MySQL mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC MySQL mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC MySQL mode=ANSI COMB downgraded p+e with bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC MySQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC MySQL mode=ANSI COMB upgraded p+e with bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC MySQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC MySQL mode=ANSI p+e without bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI p+e with bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI do without bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI do with bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC MySQL mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC MySQL mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC MySQL mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC MySQL mode=ANSI COMB downgraded p+e with bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC MySQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC MySQL mode=ANSI COMB upgraded p+e with bind - insert: (9786); fetch: (63) - FAIL
ODBC MySQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC MySQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC MySQL mode=ANSI p+e without bind - insert: (69905); fetch: (240, 63, 63, 63) - FAIL
ODBC MySQL mode=ANSI p+e with bind - insert: (69905); fetch: (63) - FAIL
ODBC MySQL mode=ANSI do without bind - insert: (69905); fetch: (240, 63, 63, 63) - FAIL
ODBC MySQL mode=ANSI do with bind - insert: (69905); fetch: (63) - FAIL
ODBC MySQL mode=ANSI BIN downgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
ODBC MySQL mode=ANSI BIN downgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
ODBC MySQL mode=ANSI BIN upgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (195, 176, 194, 145, 194, 132, 194, 145) - FAIL
ODBC MySQL mode=ANSI BIN upgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (195, 176, 194, 145, 194, 132, 194, 145) - FAIL
ODBC MySQL mode=ANSI COMB downgraded p+e with bind - insert: (69905); fetch: (63) - FAIL
ODBC MySQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
ODBC MySQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
ODBC MySQL mode=ANSI COMB upgraded p+e with bind - insert: (69905); fetch: (63) - FAIL
ODBC MySQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (195, 176, 194, 145, 194, 132, 194, 145) - FAIL
ODBC MySQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (195, 176, 194, 145, 194, 132, 194, 145) - FAIL
ODBC PostgreSQL mode=ANSI p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=ANSI p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=ANSI do without bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=ANSI do with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=ANSI BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
ODBC PostgreSQL mode=ANSI BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
ODBC PostgreSQL mode=ANSI BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI COMB downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
ODBC PostgreSQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
ODBC PostgreSQL mode=ANSI COMB upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI p+e without bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI p+e with bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI do without bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI do with bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
ODBC PostgreSQL mode=ANSI BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
ODBC PostgreSQL mode=ANSI BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI COMB downgraded p+e with bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
ODBC PostgreSQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
ODBC PostgreSQL mode=ANSI COMB upgraded p+e with bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI p+e without bind - insert: (225); fetch: (195, 161) - FAIL
ODBC PostgreSQL mode=ANSI p+e with bind - insert: (225); fetch: (195, 161) - FAIL
ODBC PostgreSQL mode=ANSI do without bind - insert: (225); fetch: (195, 161) - FAIL
ODBC PostgreSQL mode=ANSI do with bind - insert: (225); fetch: (195, 161) - FAIL
ODBC PostgreSQL mode=ANSI BIN downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=ANSI BIN downgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
ODBC PostgreSQL mode=ANSI BIN upgraded p+e with bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI BIN upgraded p+e with bind - insert: (195, 161); hex fetch: (195, 131, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI COMB downgraded p+e with bind - insert: (225); fetch: (195, 161) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
ODBC PostgreSQL mode=ANSI COMB upgraded p+e with bind - insert: (225); fetch: (195, 161) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 161); hex fetch: (195, 131, 194, 161) - FAIL
ODBC PostgreSQL mode=ANSI p+e without bind - insert: (269); fetch: (196, 141) - FAIL
ODBC PostgreSQL mode=ANSI p+e with bind - insert: (269); fetch: (196, 141) - FAIL
ODBC PostgreSQL mode=ANSI do without bind - insert: (269); fetch: (196, 141) - FAIL
ODBC PostgreSQL mode=ANSI do with bind - insert: (269); fetch: (196, 141) - FAIL
ODBC PostgreSQL mode=ANSI BIN downgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
ODBC PostgreSQL mode=ANSI BIN downgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
ODBC PostgreSQL mode=ANSI BIN upgraded p+e with bind - insert: (196, 141); fetch: (195, 132, 194, 141) - FAIL
ODBC PostgreSQL mode=ANSI BIN upgraded p+e with bind - insert: (196, 141); hex fetch: (195, 132, 194, 141) - FAIL
ODBC PostgreSQL mode=ANSI COMB downgraded p+e with bind - insert: (269); fetch: (196, 141) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
ODBC PostgreSQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
ODBC PostgreSQL mode=ANSI COMB upgraded p+e with bind - insert: (269); fetch: (196, 141) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (196, 141); fetch: (195, 132, 194, 141) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (196, 141); hex fetch: (195, 132, 194, 141) - FAIL
ODBC PostgreSQL mode=ANSI p+e without bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI do without bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI do with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=ANSI COMB downgraded p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=ANSI COMB upgraded p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=ANSI p+e without bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI do without bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI do with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=ANSI COMB downgraded p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=ANSI COMB upgraded p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=ANSI p+e without bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI do without bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI do with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=ANSI COMB downgraded p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=ANSI COMB upgraded p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=ANSI p+e without bind - insert: (69905); fetch: (240, 145, 132, 145) - FAIL
ODBC PostgreSQL mode=ANSI p+e with bind - insert: (69905); fetch: (240, 145, 132, 145) - FAIL
ODBC PostgreSQL mode=ANSI do without bind - insert: (69905); fetch: (240, 145, 132, 145) - FAIL
ODBC PostgreSQL mode=ANSI do with bind - insert: (69905); fetch: (240, 145, 132, 145) - FAIL
ODBC PostgreSQL mode=ANSI BIN downgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
ODBC PostgreSQL mode=ANSI BIN downgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
ODBC PostgreSQL mode=ANSI BIN upgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (195, 176, 194, 145, 194, 132, 194, 145) - FAIL
ODBC PostgreSQL mode=ANSI BIN upgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (195, 176, 194, 145, 194, 132, 194, 145) - FAIL
ODBC PostgreSQL mode=ANSI COMB downgraded p+e with bind - insert: (69905); fetch: (240, 145, 132, 145) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
ODBC PostgreSQL mode=ANSI COMB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
ODBC PostgreSQL mode=ANSI COMB upgraded p+e with bind - insert: (69905); fetch: (240, 145, 132, 145) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (195, 176, 194, 145, 194, 132, 194, 145) - FAIL
ODBC PostgreSQL mode=ANSI COMB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (195, 176, 194, 145, 194, 132, 194, 145) - FAIL
ODBC Vertica Database mode=ANSI p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC Vertica Database mode=ANSI p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC Vertica Database mode=ANSI do without bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC Vertica Database mode=ANSI do with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC Vertica Database mode=ANSI BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
ODBC Vertica Database mode=ANSI BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
ODBC Vertica Database mode=ANSI BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI COMB downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC Vertica Database mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
ODBC Vertica Database mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
ODBC Vertica Database mode=ANSI COMB upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC Vertica Database mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI p+e without bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI p+e with bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI do without bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI do with bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
ODBC Vertica Database mode=ANSI BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
ODBC Vertica Database mode=ANSI BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI COMB downgraded p+e with bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
ODBC Vertica Database mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
ODBC Vertica Database mode=ANSI COMB upgraded p+e with bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI p+e without bind - insert: (225); fetch: (195, 161) - FAIL
ODBC Vertica Database mode=ANSI p+e with bind - insert: (225); fetch: (195, 161) - FAIL
ODBC Vertica Database mode=ANSI do without bind - insert: (225); fetch: (195, 161) - FAIL
ODBC Vertica Database mode=ANSI do with bind - insert: (225); fetch: (195, 161) - FAIL
ODBC Vertica Database mode=ANSI BIN downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC Vertica Database mode=ANSI BIN downgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
ODBC Vertica Database mode=ANSI BIN upgraded p+e with bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI BIN upgraded p+e with bind - insert: (195, 161); hex fetch: (195, 131, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI COMB downgraded p+e with bind - insert: (225); fetch: (195, 161) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC Vertica Database mode=ANSI COMB BIN downgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
ODBC Vertica Database mode=ANSI COMB upgraded p+e with bind - insert: (225); fetch: (195, 161) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN upgraded p+e with bind - insert: (195, 161); hex fetch: (195, 131, 194, 161) - FAIL
ODBC Vertica Database mode=ANSI p+e without bind - insert: (269); fetch: (196, 141) - FAIL
ODBC Vertica Database mode=ANSI p+e with bind - insert: (269); fetch: (196, 141) - FAIL
ODBC Vertica Database mode=ANSI do without bind - insert: (269); fetch: (196, 141) - FAIL
ODBC Vertica Database mode=ANSI do with bind - insert: (269); fetch: (196, 141) - FAIL
ODBC Vertica Database mode=ANSI BIN downgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
ODBC Vertica Database mode=ANSI BIN downgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
ODBC Vertica Database mode=ANSI BIN upgraded p+e with bind - insert: (196, 141); fetch: (195, 132, 194, 141) - FAIL
ODBC Vertica Database mode=ANSI BIN upgraded p+e with bind - insert: (196, 141); hex fetch: (195, 132, 194, 141) - FAIL
ODBC Vertica Database mode=ANSI COMB downgraded p+e with bind - insert: (269); fetch: (196, 141) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN downgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
ODBC Vertica Database mode=ANSI COMB BIN downgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
ODBC Vertica Database mode=ANSI COMB upgraded p+e with bind - insert: (269); fetch: (196, 141) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN upgraded p+e with bind - insert: (196, 141); fetch: (195, 132, 194, 141) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN upgraded p+e with bind - insert: (196, 141); hex fetch: (195, 132, 194, 141) - FAIL
ODBC Vertica Database mode=ANSI p+e without bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI do without bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI do with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC Vertica Database mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC Vertica Database mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC Vertica Database mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC Vertica Database mode=ANSI COMB downgraded p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC Vertica Database mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC Vertica Database mode=ANSI COMB upgraded p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC Vertica Database mode=ANSI p+e without bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI do without bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI do with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC Vertica Database mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC Vertica Database mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC Vertica Database mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC Vertica Database mode=ANSI COMB downgraded p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC Vertica Database mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC Vertica Database mode=ANSI COMB upgraded p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC Vertica Database mode=ANSI p+e without bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI do without bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI do with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC Vertica Database mode=ANSI BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC Vertica Database mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC Vertica Database mode=ANSI BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC Vertica Database mode=ANSI COMB downgraded p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC Vertica Database mode=ANSI COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC Vertica Database mode=ANSI COMB upgraded p+e with bind - insert: (9786); fetch: (226, 152, 186) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC Vertica Database mode=ANSI p+e without bind - insert: (69905); fetch: (240, 145, 132, 145) - FAIL
ODBC Vertica Database mode=ANSI p+e with bind - insert: (69905); fetch: (240, 145, 132, 145) - FAIL
ODBC Vertica Database mode=ANSI do without bind - insert: (69905); fetch: (240, 145, 132, 145) - FAIL
ODBC Vertica Database mode=ANSI do with bind - insert: (69905); fetch: (240, 145, 132, 145) - FAIL
ODBC Vertica Database mode=ANSI BIN downgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
ODBC Vertica Database mode=ANSI BIN downgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
ODBC Vertica Database mode=ANSI BIN upgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (195, 176, 194, 145, 194, 132, 194, 145) - FAIL
ODBC Vertica Database mode=ANSI BIN upgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (195, 176, 194, 145, 194, 132, 194, 145) - FAIL
ODBC Vertica Database mode=ANSI COMB downgraded p+e with bind - insert: (69905); fetch: (240, 145, 132, 145) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
ODBC Vertica Database mode=ANSI COMB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
ODBC Vertica Database mode=ANSI COMB upgraded p+e with bind - insert: (69905); fetch: (240, 145, 132, 145) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (195, 176, 194, 145, 194, 132, 194, 145) - FAIL
ODBC Vertica Database mode=ANSI COMB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (195, 176, 194, 145, 194, 132, 194, 145) - FAIL

You can see DBD::MariaDB, DBD::Pg and DBD::SQLite work correctly. It's critical to fix DBD::ODBC to behave correctly similarly to other DBD drivers to prevent data loss.
@mjegh
Copy link
Member

mjegh commented Feb 15, 2020

Which DBD::ODBC did you use? What platform are you running on and how did you build DBD::ODBC? If you want to use unicode you need to build it with unicode support.

@pali
Copy link
Member

pali commented Feb 15, 2020

Hi @mjegh! We are using RHEL7. We have also tried to build Unicode build of DBD::ODBC and result is interesting. Some tests from above script started to work with Unicode build, but some of tests which are passing now started failing with Unicode build of DBD::ODBC. And as you can see this problem is independent of used ODBC driver. It is reproducible with MySQL ODBC, MariaDB ODBC, SQLite ODBC, Pg ODBC and Vertica ODBC. If you want output of that test script also from Unicode build of DBD::ODBC from RHEL7 box, I can provide it later in next week. But you can try to reproduce this problem also yourself with any ODBC driver to see that this is really problem in DBD::ODBC and not in RHEL7 or our build.

@pali
Copy link
Member

pali commented Feb 15, 2020

Just to note, I have already tried to debug this problem and in found out that it is really in DBD::ODBC source code. And moreover, in both normal and Unicode builds. DBD::ODBC is affected by the Perl's Unicode Bug as described in perldoc perlunicode.

@mjegh
Copy link
Member

mjegh commented Feb 15, 2020

It isn't as simple as that on Unix. The ODBC drivers you use need to support the ODBC wide APIs. I will try your code with an ODBC driver I know supports the wide APIs next week and get back to you.

@pali
Copy link
Member

pali commented Feb 15, 2020

Anyway, by coincidence @Grinnz yestarday posted to IRC #p5p channel nice explanation of this problem: https://gist.github.com/Grinnz/704b03f4d2f0dc1b84d935efc0e3c077

@pali
Copy link
Member

pali commented Feb 15, 2020

@mjegh Thanks! I checked that MySQL ODBC, MariaDB ODBC, Pg ODBC, Vertica ODBC and also SQLite ODBC supports on Linux wide UTF-16 API (those with -W suffix). So this should not be a problem.

@mjegh
Copy link
Member

mjegh commented Feb 15, 2020

There is also a possible issue with picking a varchar column type and not setting the character-set or collation - I missed that when I first glanced down the code.

@mjegh
Copy link
Member

mjegh commented Feb 15, 2020

In addition, DBD::ODBC will only use wide characters on wide column types as reported by the SQLDescribeCol call.

@mjegh
Copy link
Member

mjegh commented Feb 15, 2020

Also, which ODBC driver manager are you using. If it is iODBC you have no chance as that uses wchar_t types.

@pali
Copy link
Member

pali commented Feb 15, 2020

We are using unixODBC manager which is default on RHEL7.

@mjegh
Copy link
Member

mjegh commented Feb 15, 2020

On Windows (using postgres) the following code and output suggests it is working for me:

use 5.016;
use strict;
use warnings;
use Data::Dumper;
use DBI qw(:sql_types);
use utf8;

binmode \*STDOUT, ':utf8';
binmode \*STDERR, ':utf8';

my $h = DBI->connect('dbi:ODBC:DSN=pg', 'postgres', 'password');

eval {
    $h->do(q/drop table test/);
};

$h->do(q/create table test (a varchar(10))/);

#my $ti = $h->type_info_all;
#say Dumper($ti);

for my $val ("\xC3\xA1",
             "\N{U+C3}\N{U+A1}",
             "á",
             "č",
             "\x{263A}",
             "\N{U+263A}",
             "☺",
             "\N{U+11111}"
            ) {
    my $s = $h->prepare(q/insert into test values(?)/);
    $s->bind_param(1, $val, 
                               # {TYPE => SQL_WCHAR}
                              );
    # say "inserting $val";
    $s->execute();
}

my $s = $h->prepare(q/select * from test/);
$s->execute;
say Dumper($s->{TYPE});
my $data = $h->selectall_arrayref($s);
foreach my $row (@{$data}) {
    my $col = $row->[0];
    print length($col), ": ";
    foreach (split(//, $col)) {
        print ord($_) . ', ';
    }
    say "";
}
$h->disconnect;

$VAR1 = [
          -9
        ];

2: 195, 161,
2: 195, 161,
1: 225,
1: 269,
1: 9786,
1: 9786,
1: 9786,
1: 69905,

@pali
Copy link
Member

pali commented Feb 15, 2020

Have you tried script from the first post where are all different cases (unicode and also binary) of usage DBI? If it works on Windows?

@mjegh
Copy link
Member

mjegh commented Feb 15, 2020

Not yet. That will take a bit more work. However, are you saying my code doesn't work in your scenario?

@pali
Copy link
Member

pali commented Feb 15, 2020 •
edited
Loading

Main problem with your script is that it requires to use bind_param DBI API. We are using more DBI drivers and we would like to have unified interface, not writing specific code for each DBI driver. Which is against philosophy of DBI... We would like to avoid writing specific code for each DBI driver and from script from the first post can be seen that for DBD::MariaDB, DBD::Pg and DBD::SQLite behaves same for all usage of DBI.

@mjegh
Copy link
Member

mjegh commented Feb 15, 2020

My script works fine without bind_param on windows with postgres. i.e.,

use 5.016;
use strict;
use warnings;
use Data::Dumper;
use DBI qw(:sql_types);
use utf8;

binmode \*STDOUT, ':utf8';
binmode \*STDERR, ':utf8';

my $h = DBI->connect('dbi:ODBC:DSN=pg', 'postgres', 'password');
say $h->{Driver}->{Name} . " " . $h->get_info(17);
eval {
    $h->do(q/drop table test/);
};

$h->do(q/create table test (a varchar(10))/);

#my $ti = $h->type_info_all;
#say Dumper($ti);

for my $val ("\xC3\xA1",
             "\N{U+C3}\N{U+A1}",
             "á",
             "č",
             "\x{263A}",
             "\N{U+263A}",
             "☺",
             "\N{U+11111}"
            ) {
    my $s = $h->prepare(q/insert into test values(?)/);
#    $s->bind_param(1, $val,
#                   #{TYPE => SQL_WCHAR}
#                  );
    say "inserting $val";
    $s->execute($val);
}

my $s = $h->prepare(q/select * from test/);
$s->execute;
say Dumper($s->{TYPE});
my $data = $h->selectall_arrayref($s);
foreach my $row (@{$data}) {
    my $col = $row->[0];
    print length($col), ": ";
    foreach (split(//, $col)) {
        print ord($_) . ', ';
    }
    say "";
}
$h->disconnect;

outputs

ODBC PostgreSQL

$VAR1 = [
          -9
        ];

2: 195, 161,
2: 195, 161,
1: 225,
1: 269,
1: 9786,
1: 9786,
1: 9786,
1: 69905,

I omitted the output of the returned strings as I was using the windows console which is flawed with utf8.

@mjegh
Copy link
Member

mjegh commented Feb 15, 2020

The original script with postgres ODBC on Windows outputs the following. I've yet to understand the upgraded failures:

ODBC PostgreSQL mode=UNICODE p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=UNICODE p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=UNICODE do without bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=UNICODE do with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC PostgreSQL mode=UNICODE COMB downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
ODBC PostgreSQL mode=UNICODE COMB upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC PostgreSQL mode=UNICODE p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=UNICODE p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=UNICODE do without bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=UNICODE do with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC PostgreSQL mode=UNICODE COMB downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
ODBC PostgreSQL mode=UNICODE COMB upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 131, 195, 130, 194, 161) - FAIL
ODBC PostgreSQL mode=UNICODE p+e without bind - insert: (225); fetch: (225) - OK
ODBC PostgreSQL mode=UNICODE p+e with bind - insert: (225); fetch: (225) - OK
ODBC PostgreSQL mode=UNICODE do without bind - insert: (225); fetch: (225) - OK
ODBC PostgreSQL mode=UNICODE do with bind - insert: (225); fetch: (225) - OK
ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (195, 161); hex fetch: (195, 131, 194, 161) - FAIL
ODBC PostgreSQL mode=UNICODE COMB downgraded p+e with bind - insert: (225); fetch: (225) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
ODBC PostgreSQL mode=UNICODE COMB upgraded p+e with bind - insert: (225); fetch: (225) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (195, 161); fetch: (195, 131, 194, 161) - FAIL
ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (195, 161); hex fetch: (195, 131, 194, 161) - FAIL
ODBC PostgreSQL mode=UNICODE p+e without bind - insert: (269); fetch: (269) - OK
ODBC PostgreSQL mode=UNICODE p+e with bind - insert: (269); fetch: (269) - OK
ODBC PostgreSQL mode=UNICODE do without bind - insert: (269); fetch: (269) - OK
ODBC PostgreSQL mode=UNICODE do with bind - insert: (269); fetch: (269) - OK
ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (196, 141); fetch: (195, 132, 194, 141) - FAIL
ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (196, 141); hex fetch: (195, 132, 194, 141) - FAIL
ODBC PostgreSQL mode=UNICODE COMB downgraded p+e with bind - insert: (269); fetch: (269) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
ODBC PostgreSQL mode=UNICODE COMB upgraded p+e with bind - insert: (269); fetch: (269) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (196, 141); fetch: (195, 132, 194, 141) - FAIL
ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (196, 141); hex fetch: (195, 132, 194, 141) - FAIL
ODBC PostgreSQL mode=UNICODE p+e without bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE p+e with bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE do without bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE do with bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=UNICODE COMB downgraded p+e with bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=UNICODE COMB upgraded p+e with bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=UNICODE p+e without bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE p+e with bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE do without bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE do with bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=UNICODE COMB downgraded p+e with bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=UNICODE COMB upgraded p+e with bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=UNICODE p+e without bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE p+e with bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE do without bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE do with bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=UNICODE COMB downgraded p+e with bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
ODBC PostgreSQL mode=UNICODE COMB upgraded p+e with bind - insert: (9786); fetch: (9786) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (195, 162, 194, 152, 194, 186) - FAIL
ODBC PostgreSQL mode=UNICODE p+e without bind - insert: (69905); fetch: (69905) - OK
ODBC PostgreSQL mode=UNICODE p+e with bind - insert: (69905); fetch: (69905) - OK
ODBC PostgreSQL mode=UNICODE do without bind - insert: (69905); fetch: (69905) - OK
ODBC PostgreSQL mode=UNICODE do with bind - insert: (69905); fetch: (69905) - OK
ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (195, 176, 194, 145, 194, 132, 194, 145) - FAIL
ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (195, 176, 194, 145, 194, 132, 194, 145) - FAIL
ODBC PostgreSQL mode=UNICODE COMB downgraded p+e with bind - insert: (69905); fetch: (69905) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
ODBC PostgreSQL mode=UNICODE COMB upgraded p+e with bind - insert: (69905); fetch: (69905) - OK
ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (195, 176, 194, 145, 194, 132, 194, 145) - FAIL
ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (195, 176, 194, 145, 194, 132, 194, 145) - FAIL

@pali
Copy link
Member

pali commented Feb 15, 2020

You are using Unicode build of DBD::ODBC as it can be seen in output (mode=UNICODE). You have there passed some tests which failed in our case (as written in first post), but you have there some failed tests which passed in our case. In first post we did not use Unicode build, but I remember that something similar thing happen also when I tried that script with Unicode version of DBD::ODBC (on RHEL7). If you need I can provide output from that script with Unicode version of DBD::ODBC on RHEL7 but later in this week.

Also, could you install on Windows recent version of DBD::Pg and run that script to compare output from DBD::Pg and DBD::ODBC (with ODBC PostgreSQL driver)? I think this could be a good candidate for comparing.

@mjegh
Copy link
Member

mjegh commented Feb 15, 2020

It looks to me like in the cases where it fails it is a binary column and upgraded and the bytes passed to DBD::ODBC are twice the length they should be. For instance for "\N{U+C3}\N{U+A1}" $bins is set to encode('UTF-8', $val) and is 4 characters and 4 bytes when downgraded but it is 8 bytes when upgraded. If you pass 8 bytes on the insert with type SQL_VARBINARY that is what is going to end up in the database. I cannot for the life of me see how this could work with other drivers.

use 5.016;
use strict;
use warnings;
use Encode qw{ encode };

my $val = "\N{U+C3}\N{U+A1}";
my $bins = encode('UTF-8', $val); # this is 4 encoded bytes now
say "length of bins is " . length($bins);
{
    use bytes;
    say "length of bins is " . length($bins);
}
utf8::upgrade($bins);
say "length of bins is " . length($bins);
{
    use bytes;
    say "length of bins is " . length($bins);
}

outputs

length of bins is 4
length of bins is 4
length of bins is 4
length of bins is 8

So how can you expect the returned column to compare in:

          print __LINE__ . " " . $driver . $desc . ' BIN ' . ($upgraded ? 'upgraded' : 'downgraded') . ' p+e with bind - insert: ' . ords($bins) . '; fetch: ' . ords($fetch) . ' - ' . ($bins eq $fetch ? 'OK' : 'FAIL') . "\n";

@mjegh
Copy link
Member

mjegh commented Feb 15, 2020

+rebind_param 1 "�¡" (size SvCUR=8/SvLEN=16/max=0) svtype:7, value type:1, sql type:0

@pali
Copy link
Member

pali commented Feb 15, 2020

It does not matter if Perl scalar is upgraded or downgraded. It always stores same value, as can be seen in output of sub ords function. You should not use use bytes as it is not doing what you think. Just call length without use bytes.

Really, look into @Grinnz explanation about scalar and characters problem.

Other DBI drivers (DBD::Pg, DBD::SQLite, DBD::MariaDB) implemens it correctly.

@mjegh
Copy link
Member

mjegh commented Feb 15, 2020

I understand the difference between bytes and characters. The point is:

  1. at the time $bins is bound the scalar has 8 bytes in it
  2. you bound it as a binary type and inserted it into a binary type
use 5.016;
use strict;
use warnings;
use Encode qw{ encode };
use Devel::Peek;

my $val = "\N{U+C3}\N{U+A1}";
my $bins = encode('UTF-8', $val); # this is 4 encoded bytes now
Dump($bins);
utf8::upgrade($bins);
Dump($bins);

SV = PV(0xc0dd88) at 0xb10098
  REFCNT = 1
  FLAGS = (PADMY,POK,pPOK)
  PV = 0x2790238 "\303\203\302\241"\0
  CUR = 4
  LEN = 16
SV = PV(0xc0dd88) at 0xb10098
  REFCNT = 1
  FLAGS = (PADMY,POK,pPOK,UTF8)
  PV = 0x2790238 "\303\203\302\203\303\202\302\241"\0 [UTF8 "\x{c3}\x{83}\x{c2}\x{a1}"]
  CUR = 8
  LEN = 16

@pali
Copy link
Member

pali commented Feb 15, 2020

So if both cases (prior and after upgrade) $bins contains sequence of 4 numbers: 195, 131, 194, 161. And thefore it should put there four numbers into database. But you said that ODBC put 8 number, instead of 4 which is wrong.

@mjegh
Copy link
Member

mjegh commented Feb 15, 2020

There must be some misunderstanding here and you are going to have to explain it better to me. The Devel::Peek output above doesn't show 4 bytes in both cases.

use 5.016;
use strict;
use warnings;
use Encode qw{ encode };
use Devel::Peek;

my $val = "\N{U+C3}\N{U+A1}";
Dump($val);
my $bins = encode('UTF-8', $val); # this is 4 encoded bytes now
Dump($bins);
utf8::upgrade($bins);
Dump($bins);

SV = PV(0xe6d128) at 0xd100c8
  REFCNT = 1
  FLAGS = (PADMY,POK,pPOK,UTF8)
  PV = 0x29f0358 "\303\203\302\241"\0 [UTF8 "\x{c3}\x{a1}"]
  CUR = 4
  LEN = 16
SV = PV(0xe6dd88) at 0xd104e8
  REFCNT = 1
  FLAGS = (PADMY,POK,pPOK)
  PV = 0x29f03b8 "\303\203\302\241"\0
  CUR = 4
  LEN = 16
SV = PV(0xe6dd88) at 0xd104e8
  REFCNT = 1
  FLAGS = (PADMY,POK,pPOK,UTF8)
  PV = 0x29f03b8 "\303\203\302\203\303\202\302\241"\0 [UTF8 "\x{c3}\x{83}\x{c2}\x{a1}"]
  CUR = 8
  LEN = 16

So you seem to be suggesting $bins is the same before and after upgrade but it doesn't look that way to me.
I'm not trying to be argumentative, I just need more help understanding why you think DBD::ODBC did the wrong thing or I have no chance of working out how to change it. I realise the weight of evidence is for DBD::ODBC being wrong but if you cannot make me understand why it isn't going to change (not at least by me).
If you can explain why $bins is the same before and after upgrade when it looks different to me in Devel::Peek output I might have a chance of seeing where to go.

@pali
Copy link
Member

pali commented Feb 15, 2020 •
edited
Loading

So you seem to be suggesting $bins is the same before and after upgrade but it doesn't look that way to me.

Yes, it is same. This is common mistake in interpreting output from the Devel::Peek. This is why I suggested to look at output from the sub ords function as it is easier to understand it as from Devel::Peek::Dump output. As I already pointed, content of Perl scalar is explained in Grinnz post.

my $val = "\N{U+C3}\N{U+A1}";
Dump($val);

Important part of Dump here is:

[UTF8 "\x{c3}\x{a1}"]

It means that $val contains sequence of two numbers: 0xC3, 0xA1 (or in decimal: 195, 161). And internal perl representation is UTF-8.

my $bins = encode('UTF-8', $val); # this is 4 encoded bytes now
Dump($bins);

Important part of Dump is:

 "\303\203\302\241"\0

It means that $bins contains sequence of 4 numbers: 0303, 0203, 0302, 0241 (or in hex 0xC3, 0x83, 0xC2, 0xA1; or in decimal: 195, 131, 194, 161).

utf8::upgrade($bins);
Dump($bins);

And here important part of Dump is:

[UTF8 "\x{c3}\x{83}\x{c2}\x{a1}"]

Which means that $bins still contains sequence of 4 numbers: 0xC3, 0x83, 0xC2, 0xA1; or in decimal: 195, 131, 194, 161. And internal representation is UTF-8. So content of $bins was not changed, it still contains same data: numbers 195, 131, 194, 161.

You can also check that Perl scalar prior and after upgrade is same:

use Encode;
my $val1 = "\N{U+C3}\N{U+A1}";
my $bins1 = encode('UTF-8', $val1);
utf8::upgrade($bins1);
my $val2 = "\N{U+C3}\N{U+A1}";
my $bins2 = encode('UTF-8', $val2);
if ($bins1 eq $bins2) { print "bins1 and bins2 are same\n" } else { print "bins1 and bins2 are different\n" }

It prints:

bins1 and bins2 are same

If you can explain why $bins is the same before and after upgrade when it looks different to me in Devel::Peek output

Problem here is intepretation of Devel::Peek output. There is common mistake how to read it correctly. If scalar has UTF8 flag you need to look at UTF8 Dump output. If scalar does not have UTF8 flag set you must not look at UTF8 Dump outout. LEN and CUR contains size for actual internal representation (UTF-8 or not-UTF-8) and not number characters stored in scalar (this is another common mistake). There are similar mistakes when reading floating point numbers in scalar. If scalar does not have set NOK flag you must not look at NV part of output. Similarly if scalar does not have set IOK flag you must not look at IV part if output. Basically Devel::Peek::Dump show internal memory of scalar, including (probably) unused / uninitialized data and it needed to look at scalar flags to determinate which scalar slots are valid / filled.

To avoid any confusion of above problem I'm using following ords function to print Perl scalar:

sub ords { '(' . (join ', ', map ord, split //, $_[0] // '') . ')' }

(as Perl split function correctly handles all above internals).

So lets look that bins1 and bins2 are really same and what is stored there:

sub ords { '(' . (join ', ', map ord, split //, $_[0] // '') . ')' }
use Encode;
my $val1 = "\N{U+C3}\N{U+A1}";
my $bins1 = encode('UTF-8', $val1);
utf8::upgrade($bins1);
my $val2 = "\N{U+C3}\N{U+A1}";
my $bins2 = encode('UTF-8', $val2);
print "val1: " . ords($val1) . "\n";
print "val2: " . ords($val2) . "\n";
print "bins1: " . ords($bins1) . "\n";
print "bins2: " . ords($bins2) . "\n";

It prints:

val1: (195, 161)
val2: (195, 161)
bins1: (195, 131, 194, 161)
bins2: (195, 131, 194, 161)

Which is correct. val1 and val2 are not modified and contains Unicode code points (195, 161). Then encode converts Unicode code points to their UTF-8 representation to 4 numbers (195, 131, 194, 161) in bins1 and bins2. And additionally bins1 is upgraded -- and still contains same content.

I hope that it is more clear right now. Reading Devel::Peek::Dump output is sometimes really a pain (need to first look at FLAGS and then at slots; and somtimes it prints output in octal and sometimes in hexadecimal).

@mjegh
Copy link
Member

mjegh commented Feb 15, 2020

Thanks @pali for the explanation. To move on I need to work out how in XS to know this and how to convert it to the bytes (which are required by ODBC) in the SQLBindParam call.

@pali
Copy link
Member

pali commented Feb 15, 2020 •
edited
Loading

In XS: SvPV() macro returns raw readonly char* buffer and STRLEN length of that buffer. Following SvUTF8() macro (must be called after SvPV()) returns what is internal represnetation of previously returned raw char* buffer: either UTF-8 or Latin1. Based on this SvUTF8() result you need to convert returnd raw char* buffer to what representation you need (UTF-16, UTF-32, UTF-8, Latin1, whatever...). In XS there is a function utf8_to_bytes() which modifies in-place char* buffer from UTF-8 to Latin1. Beware that SvPV() returns readonly buffer, so first you need to make copy of it. Similarly there is a function bytes_to_utf8() which do conversion from Latin1 to UTF-8, but do not modify it in place, but returns newly allocated buffer. Sometimes it is a pain to do it correclty (prevent memory leaks, correcly pass buffers, and its lengths, etc...).

If you want to return char* buffer always in UTF-8 you can use SvPVutf8() macro (so you do not have to do following SvUTF8() call and converting yourself). It again returns read-only buffer. Similarly there is a SvPVbyte() macro which returns char* buffer always in Latin1.

I hope that this helps you to how to construct char* buffers from SV* perl scalar correctly.

@Grinnz
Copy link

Grinnz commented Feb 15, 2020

BTW an easy built in way to achieve what the "ords" function does is: sprintf '%vd', "\N{U+C3}\N{U+A1}" -> '195.161', sprintf '%vX', "\N{U+C3}\N{U+A1}" -> 'C3.A1'

@mjegh
Copy link
Member

mjegh commented Feb 16, 2020

I've singularly failed to change the code to make this work for binaries. Can you point me to where DBD::SQLite or DBD::Pg does this properly?

@mjegh
Copy link
Member

mjegh commented Feb 16, 2020

ok, with a small change very specific to binding a binary type (probably doesn't work for inout parameters yet):

50 ODBC PostgreSQL mode=UNICODE p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
60 ODBC PostgreSQL mode=UNICODE p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
68 ODBC PostgreSQL mode=UNICODE do without bind - insert: (195, 161); fetch: (195, 161) - OK
77 ODBC PostgreSQL mode=UNICODE do with bind - insert: (195, 161); fetch: (195, 161) - OK
128 ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
130 ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
128 ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
130 ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
180 ODBC PostgreSQL mode=UNICODE COMB downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
181 ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
183 ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
180 ODBC PostgreSQL mode=UNICODE COMB upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
181 ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
183 ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
50 ODBC PostgreSQL mode=UNICODE p+e without bind - insert: (195, 161); fetch: (195, 161) - OK
60 ODBC PostgreSQL mode=UNICODE p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
68 ODBC PostgreSQL mode=UNICODE do without bind - insert: (195, 161); fetch: (195, 161) - OK
77 ODBC PostgreSQL mode=UNICODE do with bind - insert: (195, 161); fetch: (195, 161) - OK
128 ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
130 ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
128 ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
130 ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
180 ODBC PostgreSQL mode=UNICODE COMB downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
181 ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
183 ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
180 ODBC PostgreSQL mode=UNICODE COMB upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
181 ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); fetch: (195, 131, 194, 161) - OK
183 ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (195, 131, 194, 161); hex fetch: (195, 131, 194, 161) - OK
50 ODBC PostgreSQL mode=UNICODE p+e without bind - insert: (225); fetch: (225) - OK
60 ODBC PostgreSQL mode=UNICODE p+e with bind - insert: (225); fetch: (225) - OK
68 ODBC PostgreSQL mode=UNICODE do without bind - insert: (225); fetch: (225) - OK
77 ODBC PostgreSQL mode=UNICODE do with bind - insert: (225); fetch: (225) - OK
128 ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
130 ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
128 ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
130 ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
180 ODBC PostgreSQL mode=UNICODE COMB downgraded p+e with bind - insert: (225); fetch: (225) - OK
181 ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
183 ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
180 ODBC PostgreSQL mode=UNICODE COMB upgraded p+e with bind - insert: (225); fetch: (225) - OK
181 ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (195, 161); fetch: (195, 161) - OK
183 ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (195, 161); hex fetch: (195, 161) - OK
50 ODBC PostgreSQL mode=UNICODE p+e without bind - insert: (269); fetch: (269) - OK
60 ODBC PostgreSQL mode=UNICODE p+e with bind - insert: (269); fetch: (269) - OK
68 ODBC PostgreSQL mode=UNICODE do without bind - insert: (269); fetch: (269) - OK
77 ODBC PostgreSQL mode=UNICODE do with bind - insert: (269); fetch: (269) - OK
128 ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
130 ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
128 ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
130 ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
180 ODBC PostgreSQL mode=UNICODE COMB downgraded p+e with bind - insert: (269); fetch: (269) - OK
181 ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
183 ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
180 ODBC PostgreSQL mode=UNICODE COMB upgraded p+e with bind - insert: (269); fetch: (269) - OK
181 ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (196, 141); fetch: (196, 141) - OK
183 ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (196, 141); hex fetch: (196, 141) - OK
50 ODBC PostgreSQL mode=UNICODE p+e without bind - insert: (9786); fetch: (9786) - OK
60 ODBC PostgreSQL mode=UNICODE p+e with bind - insert: (9786); fetch: (9786) - OK
68 ODBC PostgreSQL mode=UNICODE do without bind - insert: (9786); fetch: (9786) - OK
77 ODBC PostgreSQL mode=UNICODE do with bind - insert: (9786); fetch: (9786) - OK
128 ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
130 ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
128 ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
130 ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
180 ODBC PostgreSQL mode=UNICODE COMB downgraded p+e with bind - insert: (9786); fetch: (9786) - OK
181 ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
183 ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
180 ODBC PostgreSQL mode=UNICODE COMB upgraded p+e with bind - insert: (9786); fetch: (9786) - OK
181 ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
183 ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
50 ODBC PostgreSQL mode=UNICODE p+e without bind - insert: (9786); fetch: (9786) - OK
60 ODBC PostgreSQL mode=UNICODE p+e with bind - insert: (9786); fetch: (9786) - OK
68 ODBC PostgreSQL mode=UNICODE do without bind - insert: (9786); fetch: (9786) - OK
77 ODBC PostgreSQL mode=UNICODE do with bind - insert: (9786); fetch: (9786) - OK
128 ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
130 ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
128 ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
130 ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
180 ODBC PostgreSQL mode=UNICODE COMB downgraded p+e with bind - insert: (9786); fetch: (9786) - OK
181 ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
183 ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
180 ODBC PostgreSQL mode=UNICODE COMB upgraded p+e with bind - insert: (9786); fetch: (9786) - OK
181 ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
183 ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
50 ODBC PostgreSQL mode=UNICODE p+e without bind - insert: (9786); fetch: (9786) - OK
60 ODBC PostgreSQL mode=UNICODE p+e with bind - insert: (9786); fetch: (9786) - OK
68 ODBC PostgreSQL mode=UNICODE do without bind - insert: (9786); fetch: (9786) - OK
77 ODBC PostgreSQL mode=UNICODE do with bind - insert: (9786); fetch: (9786) - OK
128 ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
130 ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
128 ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
130 ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
180 ODBC PostgreSQL mode=UNICODE COMB downgraded p+e with bind - insert: (9786); fetch: (9786) - OK
181 ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
183 ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
180 ODBC PostgreSQL mode=UNICODE COMB upgraded p+e with bind - insert: (9786); fetch: (9786) - OK
181 ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (226, 152, 186); fetch: (226, 152, 186) - OK
183 ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (226, 152, 186); hex fetch: (226, 152, 186) - OK
50 ODBC PostgreSQL mode=UNICODE p+e without bind - insert: (69905); fetch: (69905) - OK
60 ODBC PostgreSQL mode=UNICODE p+e with bind - insert: (69905); fetch: (69905) - OK
68 ODBC PostgreSQL mode=UNICODE do without bind - insert: (69905); fetch: (69905) - OK
77 ODBC PostgreSQL mode=UNICODE do with bind - insert: (69905); fetch: (69905) - OK
128 ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
130 ODBC PostgreSQL mode=UNICODE BIN downgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
128 ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
130 ODBC PostgreSQL mode=UNICODE BIN upgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
180 ODBC PostgreSQL mode=UNICODE COMB downgraded p+e with bind - insert: (69905); fetch: (69905) - OK
181 ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
183 ODBC PostgreSQL mode=UNICODE COMB BIN downgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK
180 ODBC PostgreSQL mode=UNICODE COMB upgraded p+e with bind - insert: (69905); fetch: (69905) - OK
181 ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); fetch: (240, 145, 132, 145) - OK
183 ODBC PostgreSQL mode=UNICODE COMB BIN upgraded p+e with bind - insert: (240, 145, 132, 145); hex fetch: (240, 145, 132, 145) - OK

@mjegh
Copy link
Member

mjegh commented Feb 16, 2020

It is far more complex to write a fix for binary columns in this case when it is an in/out parameter but if you'd like to try the change for in parameters let me know and I'll do a dev release.

Thanks for your help.

@pali
Copy link
Member

pali commented Feb 17, 2020

I have extended test script from the first post, to include more combination for testing, download here: db-utf8.pl.gz. Output from that script on our RHEL7 box is here: output.log.

I also compiled Unicode build of DBD::ODBC and run it on same RHEL7 box. But for some unknown reasons, DBD::ODBC freezed while executing statements via MySQL-ODBC driver. So I excluded MySQL-ODBC from testing script and output is here: output_unicode.log. If you are interested here is stack trace when DBD::ODBC freezed during execution of MySQL-ODBC gdb.log. It happened only with Unicode build of DBD::ODBC. With normal build there was no freeze.

Could you run your tests on Windows with above extended test script if with your changes? Because on our RHEL7 boxes that script discovered another issues with upgraded/downgraded scalars in DBD::ODBC (which are not affected by other DBD::SQLite, DBD::MariaDB or DBD::Pg drivers).

@mjegh
Copy link
Member

mjegh commented Feb 17, 2020

Thanks @pali. I'll try and take a look today.

@mjegh
Copy link
Member

mjegh commented Feb 17, 2020

Postgres ODBC driver on windows with new test code - all tests succeeded.

@pali
Copy link
Member

pali commented Feb 17, 2020

Great! Would you publish changes to DBD::ODBC so we could try it also on RHEL7?

@mjegh
Copy link
Member

mjegh commented Feb 17, 2020

Sure. I'll commit the changes now to the master branch on the repository. It will be 1.62_1 experimental for now as although it is a minor change code-wise it is a major change in behaviour.

@mjegh
Copy link
Member

mjegh commented Feb 17, 2020

Pushed to https://github.com/perl5-dbi/DBD-ODBC

@pali
Copy link
Member

pali commented Feb 18, 2020

@mjegh Thank you for your changes! I compiled version from git (with enabled Unicode) and run extended script from #18 (comment) post. But on RHEL7 box with PostgreSQL ODBC driver it failed on following tests:

ODBC PostgreSQL mode=UNICODE NORM downgraded p+e without bind - insert: (195, 161); fetch: (225) - FAIL
ODBC PostgreSQL mode=UNICODE NORM downgraded do without bind - insert: (195, 161); fetch: (225) - FAIL
ODBC PostgreSQL mode=UNICODE NORM downgraded p+e without bind - insert: (195, 161); fetch: (225) - FAIL
ODBC PostgreSQL mode=UNICODE NORM downgraded do without bind - insert: (195, 161); fetch: (225) - FAIL

Whole output with all tested drivers and all passed/failed tests is attached here: full.log

@mjegh
Copy link
Member

mjegh commented Feb 18, 2020

Thanks @pali. That must be a difference between the unix ODBC driver manager or the postgres ODBC driver for unix. I'll try and have a look at it.

@pali
Copy link
Member

pali commented Feb 18, 2020

If you look at full output log, interesting is that there are tests which are passing on Pg ODBC and Vertica ODBC, but are failing with MariaDB ODBC and SQLite ODBC.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
None yet
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
4 participants
@choroba @mjegh @Grinnz @pali