perl5-dbi / dbd-odbc

DBD module interfacing the ODBC databases

DBD::ODBC -- DBD module interfacing the ODBC databases.

See LICENSE-AND-COPYRIGHT section in ODBC.pm for usage and distribution rights.

DEPENDENCIES

Build, test and install Perl 5 (as per DBI specifications/compatibility)
It is very important to TEST it and INSTALL it.

Build, test and install the DBI module (at least DBI 1.609).
It is very important to TEST it and INSTALL it.

Remember to *read* the DBD::ODBC.pm POD documentation and the
DBD::ODBC::Changes.pm POD documentation.

BUILDING:

set-up these environment variables:

DBI_DSN   The dbi data source, e.g. 'dbi:ODBC:YOUR_DSN_HERE'

DBI_USER  The username to use to connect to the database

DBI_PASS  The username to use to connect to the database

ODBCHOME  (Unix only) The dir your driver manager is installed in
          or specify this via -o argument to Makefile.PL

DBD_ODBC_UNICODE Any value here will set the default install to
                 attempt to turn on UNICODE support.

If you want UNICODE support on non-Windows platforms specify -u switch to Makefile.PL. If you don't want UNICODE support on Windows specify the -nou switch to Makefile.PL. On non-Windows platforms all UNICODE features will work correctly with the unixODBC driver manager.

If the Makefile.PL finds iODBC and you would prefer to build with unixODBC you can use the -x switch to favor unixODBC. This only happens in rare case where you have binary packages of both installed but you can only have development packages on one installed and DBD::ODBC locates iODBC first. This quite often happens on Ubuntu and other Debian based Linux systems where an incomplete iODBC is often installed.

perl Makefile.PL

make (or nmake/dmake, if VC++ on Win32)

make test (or nmake/dmake, if VC++ on Win32)

TESTING

make test

make test TEST_VERBOSE=1 (if any of the t/* tests fail)

make install (if the tests look okay)

Note that the tests currently all pass when using the Microsoft SQL server driver up to SQL Server 2008 and many other ODBC drivers on Windows and UNIX (too numerous to mention here).

To run an individual test use:

prove -vb t/test.t

If the tests from t/09bind.t fail, that is an indication of lack of ODBC Level 2 functionality. This does not (necessarily) mean that your installation is broken. It does indicate that your ODBC driver does not support certain level 2 calls (see below). All other tests should pass, however, since I've tested with a limited number of ODBC drivers, I could have something wrong in the test. Please notify me if you have an incompatibility in the other tests. (For example, some Paradox ODBC drivers could fail, if they don't support long file names, since in Paradox file names are tableName.db.). Please let me know about any incompatibilities you encounter. I will say, though, that I may not be able to reproduce or fix problems without some help, since I can't possibly install all the known ODBC drivers. Please try to "solve" the problem, in addition to discovering it.

If any of the tests fail and you are using SQL Server and Windows drivers, ensure you updated to MDAC 2.7 or later.

NOTES on ODBC Drivers and Compatibility with DBD-ODBC

This version utilizes at least one "Level 2" ODBC call (SQLDescribeParam). This will affect compatibility with specific ODBC drivers. If the driver is not level 2 (or does not support the level 2 function(s) required), then full compatibility will not be available. The best thing to do is build DBD::ODBC against an ODBC driver manager like unixODBC (http://www.unixodbc.org) as it will resolve many incompatibilities between ODBC versions for you.

IF YOU HAVE PROBLEMS:

Do not hand edit the generated Makefile unless you are completely sure you understand the implications! Always try to make changes via the Makefile.PL command line and/or editing the Makefile.PL.

You should not need to make any changes. If you do please let me know so that I can try to make it automatic in a later release.

This software is supported via the dbi-users mailing list. For more information and to keep informed about progress you can join the mailing list via http://dbi.perl.org (if you are unable to use the web you can subscribe by sending a message to [email protected].

Please post details of any problems (or changes you needed to make) to [email protected]. But note...

** IT IS IMPORTANT TO INCLUDE THE FOLLOWING INFORMATION:

1. A complete log of a all steps of the build, e.g.:

perl Makefile.PL           (do a make realclean first)

make

make test

make test TEST_VERBOSE=1   (if any tests fail)

2. Full details of which software you are using, including:

Perl version (the output of perl -V)

ODBC Driver and version

ODBC Driver manager used and version

It is important to check that you are using the latest version before posting. If you're not then I'm very likely to simply say "upgrade to the latest". You would do yourself a favour by upgrading beforehand.

Please remember that I'm very busy. Try to help yourself first, then try to help me help you by following these guidelines carefully.

Regards, Tim, Jeff and Martin.

dbd-odbc's Issues

Native error code never passed to DBI

Excerpt from pod/DBD::ODBC#odbc_getdiagrec:

odbc_getdiagrec

:

All of the state, native and message text are already passed to DBI
via its set_err method so this method does not really tell you
anything you cannot already get from DBI except when there is more
than one diagnostic.

This is not correct, because all calls of DBIh_SET_ERR_ get as argument err passed a 1 or 0 ❌

DBD::ODBC does not connect to server, while unixodbc does

May be it's not related to DBD::ODBC, but I encountered problem with FreeTDS 1.3rc2, and the problem occurs only for Perl code.
All worked fine with 1.2 version of driver, but I needed to have sqlserver 2019 and utf8 collation, so I switched to new version.
And my environmet configuration is:
[application]

my $dsn_odbc  = 'dbi:ODBC:Driver=FreeTDS13;Servername=FreeTDS_local_19';
my $dbh =  $dbh = myDBI->connect(our $dsn_odbc, our $db_user, our $db_pasw);

[/etc/odbcinst.ini]

[FreeTDS13]
        Driver=/usr/lib/x86_64-linux-gnu/libtdsodbc.so
        FileUsage=1

[/etc/odbc.ini] (it seems FreeTDS ignore odbc.ini, but anyway)

[FreeTDS_local_19]
       Driver = FreeTDS13
        Server = localhost
        TDS_Version = 7.4
        Port = 1433

[/etc/freetds.conf]

[FreeTDS_local_19]
        Driver = FreeTDS13
        Server = localhost
        TDS_Version = 7.4
        Port = 1433

isql result:

$ isql -v FreeTDS_local_19 SA password
+---------------------------------------+
| Connected!                            |
|                                       |
| sql-statement                         |
| help [tablename]                      |
| quit                                  |
|                                       |
+---------------------------------------+
SQL>

Application run result:
DBI connect('Driver=FreeTDS13;Servername=FreeTDS_local_19','SA',...) failed: [unixODBC][FreeTDS][SQL Server]Unable to connect: Adaptive Server is unavailable or does not exist (SQL-08S01) [state was 08S01 now 08001]
[unixODBC][FreeTDS][SQL Server]Unable to connect to data source (SQL-08001) [state was 08001 now 01000]
[unixODBC][FreeTDS][SQL Server]Unknown host machine name. (SQL-01000)

Install fails on Ubuntu 21.04: Failed test t/02simple.t : ReadOnly set

I am trying to install DBD::ODBC on Ubuntu 21.04:

$ perl Makefile.PL 

**********
	Remember to actually *READ* the README file!
	And re-read it if you have any problems.

**********

OSNAME: linux
LANG: en_US.UTF-8
ODBCHOME: 
LD_LIBRARY_PATH: /home/hakon/lib
DBROOT: 
WINDIR: 
II_SYSTEM: 
DBD_ODBC_UNICODE: 
Perl: 5.032000
ExtUtils::MakeMaker: 7.62
Command line options:
  w! = undef
  o=s = 
  e! = undef
  g! = 0
  x! = undef
  u! = undef


Your LANG environment variable is set to "en_US.UTF-8"
This is known to cause problems in some perl installations - even stopping
this Makefile.PL from running without errors. If you have problems please
try re-running with LANG unset or with the utf part of LANG removed.

Looking for odbc_config in : nowhere
Looking for odbc_config in (PATH) /home/hakon/perlbrew/bin:/home/hakon/perlbrew/perls/perl-5.32.0/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
  odbc_config not found
Looking for iodbc-config in PATH /home/hakon/perlbrew/bin:/home/hakon/perlbrew/perls/perl-5.32.0/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin
  iodbc_config not found
odbc_config not found - ok, there are other things I can do
Still trying to guess ODBCHOME - looking for headers now
  trying /usr/include
  Found sql.h, sqlext.h, sqltypes.h in /usr/include
Using ODBCHOME /usr
  Looking for iODBC libs in /usr/lib
  Looking for iODBC libs in /usr/local/lib
  Looking for iODBC libs in /usr/include/x86_64-linux-gnu
  Looking for iODBC libs in /usr/lib
  Looking for iODBC libs in /lib/x86_64-linux-gnu
  Looking for iODBC libs in /lib/../lib
  Looking for iODBC libs in /usr/lib/x86_64-linux-gnu
  Looking for iODBC libs in /usr/lib/../lib
  Looking for iODBC libs in /lib
  Looking for iODBC libs in /lib64
  Looking for iODBC libs in /usr/lib64
  Looking for iODBC libs in /usr
  Looking for iODBC libs in /usr/lib
  Looking for unixODBC libs in /usr/lib
  Looking for unixODBC libs in /usr/local/lib
  Looking for unixODBC libs in /usr/include/x86_64-linux-gnu
  Looking for unixODBC libs in /usr/lib
  Looking for unixODBC libs in /lib/x86_64-linux-gnu
    Found unixODBC libs /lib/x86_64-linux-gnu/libodbc.a,/lib/x86_64-linux-gnu/libodbc.so,/lib/x86_64-linux-gnu/libodbc.so.1,/lib/x86_64-linux-gnu/libodbc.so.2,/lib/x86_64-linux-gnu/libodbc.so.2.0.0,/lib/x86_64-linux-gnu/libodbccr.a,/lib/x86_64-linux-gnu/libodbccr.so,/lib/x86_64-linux-gnu/libodbccr.so.1,/lib/x86_64-linux-gnu/libodbccr.so.2,/lib/x86_64-linux-gnu/libodbccr.so.2.0.0,/lib/x86_64-linux-gnu/libodbcinst.a,/lib/x86_64-linux-gnu/libodbcinst.so,/lib/x86_64-linux-gnu/libodbcinst.so.1,/lib/x86_64-linux-gnu/libodbcinst.so.2,/lib/x86_64-linux-gnu/libodbcinst.so.2.0.0 in /lib/x86_64-linux-gnu

This looks like a unixodbc type of driver manager.
Looking for odbcinst
  Found odbcinst in /usr/bin
  odbcinst -j reports:

unixODBC 2.3.6
DRIVERS............: /etc/odbcinst.ini
SYSTEM DATA SOURCES: /etc/odbc.ini
FILE DATA SOURCES..: /etc/ODBCDataSources
USER DATA SOURCES..: /home/hakon/.odbc.ini
SQLULEN Size.......: 8
SQLLEN Size........: 8
SQLSETPOSIROW Size.: 8

Please note these files as they are where you define your ODBC drivers and data sources.

Looking for odbc_config to get cflags
  odbc_config not found - ok
Warning: LD_LIBRARY_PATH=/home/hakon/lib doesn't include /lib/x86_64-linux-gnu

Checking if your kit is complete...
Looks good
Using DBI 1.643 (for perl 5.032000 on x86_64-linux) installed in /home/hakon/perlbrew/perls/perl-5.32.0/lib/site_perl/5.32.0/x86_64-linux/auto/DBI/
Using DBI 1.643 (for perl 5.032000 on x86_64-linux) installed in /home/hakon/perlbrew/perls/perl-5.32.0/lib/site_perl/5.32.0/x86_64-linux/auto/DBI/
Generating a Unix-style Makefile
Writing Makefile for DBD::ODBC
Writing MYMETA.yml and MYMETA.json

The DBD::ODBC tests will use these values for the database connection:
    DBI_DSN=dbi:ODBC:mydsn     e.g. dbi:ODBC:demo
    DBI_USER=hakon
    DBI_PASS=???????

$ make
$ make test
"/home/hakon/perlbrew/perls/perl-5.32.0/bin/perl" -MExtUtils::Command::MM -e 'cp_nonempty' -- ODBC.bs blib/arch/auto/DBD/ODBC/ODBC.bs 644
PERL_DL_NONLAZY=1 "/home/hakon/perlbrew/perls/perl-5.32.0/bin/perl" "-MExtUtils::Command::MM" "-MTest::Harness" "-e" "undef *Test::Harness::Switches; test_harness(0, 'blib/lib', 'blib/arch')" t/*.t
t/01base.t ................... ok   
t/02simple.t ................. 1/66 # 
# Perl 5.32.0
# osname=linux, osvers=5.11.0-16-generic, archname=x86_64-linux
# Using DBI 1.643
# Using DBD::ODBC 1.61
# Using DBMS_NAME 'MySQL'
# Using DBMS_VER '8.0.25-0ubuntu0.21.04.1'
# Using DRIVER_NAME 'libmyodbc8w.so'
# Using DRIVER_VER '08.00.0026'
# odbc_has_unicode 

#   Failed test 'ReadOnly set'
#   at t/02simple.t line 63.
#          got: '0'
#     expected: '1'
t/02simple.t ................. 15/66 # Looks like you failed 1 test of 66.
t/02simple.t ................. Dubious, test returned 1 (wstat 256, 0x100)
Failed 1/66 subtests 
t/03dbatt.t .................. 1/31 # 
# N.B. Some drivers (postgres/cache) may return ODBC 2.0 column names for the SQLTables result-set e.g. TABLE_QUALIFIER instead of TABLE_CAT
t/03dbatt.t .................. ok     
t/05meth.t ................... ok     
t/07bind.t ................... ok     
t/08bind2.t .................. ok   
t/09multi.t .................. ok   
t/10handler.t ................ ok     
t/12blob.t ................... ok     
t/20SqlServer.t .............. ok     
t/30Oracle.t ................. ok   
t/40UnicodeRoundTrip.t ....... ok     
t/41Unicode.t ................ ok     
t/45_unicode_varchar.t ....... # Driver: libmyodbc8w.so
t/45_unicode_varchar.t ....... skipped: Not MS SQL Server
t/50_odbc_utf8_on.t .......... ok   
t/70execute_array_dbi.t ...... # 
# 
# NOTE: This tests execute_array and execute_for_fetch using DBI's version and not the native DBD::ODBC execute_for_fetch. It should work as it is using nothing special in DBD::ODBC other than the normal methods.
t/70execute_array_dbi.t ...... ok     
t/70execute_array_native.t ... # 
# 
# NOTE: This is an experimental test. Since DBD::ODBC added the execute_for_fetch method this tests the native method and not DBI's fallback method. If you fail this test it probably means the ODBC driver you are using does not have sufficient support (or is buggy) for array operations. If you pass this test your ODBC Driver seems ok and you can get faster insert/update/delete operations using DBI's execute_array or execute_for_fetch methods by setting the odbc_array_operations to true.
# 
# If this test fails it should not stop you installing DBD::ODBC but if it fails with an error other than something indicating 'connection busy' I'd strongly suggest you don't set odbc_array_operations and stick with DBI's default implementation.
# 
# If this test fails for your driver I'd like to hear about it so I can compile a list of working drivers and perhaps pass bug reports on to the maintainers. Please rerun this test with TEST_VERBOSE set or using prove and send the results to the dbi-users mailing list.
# 
# 
# Perl 5.32.0
# osname=linux, osvers=5.11.0-16-generic, archname=x86_64-linux
# Using DBI 1.643
# Using DBD::ODBC 1.61
# Using DBMS_NAME 'MySQL'
# Using DBMS_VER '8.0.25-0ubuntu0.21.04.1'
# Using DRIVER_NAME 'libmyodbc8w.so'
# Using DRIVER_VER '08.00.0026'
# odbc_has_unicode 0
t/70execute_array_native.t ... ok     
t/80_odbc_diags.t ............ ok   
t/82_table_info.t ............ ok   
t/87_odbc_lob_read.t ......... skipped: Not MS SQL Server
t/90_trace_flags.t ........... ok   
t/odbc_describe_parameter.t .. ok     
t/pod-coverage.t ............. ok   
t/pod.t ...................... ok   
t/rt_101579.t ................ ok   
t/rt_38977.t ................. ok     
t/rt_39841.t ................. ok     
t/rt_39897.t ................. ok   
t/rt_43384.t ................. ok   
t/rt_46597.t ................. ok   
t/rt_50852.t ................. ok   
t/rt_57957.t ................. 1/9 # 
# Some of these tests may fail for your driver - please let me know if they do along with the strings MySQL/libmyodbc8w.so
t/rt_57957.t ................. ok   
t/rt_59621.t ................. ok     
t/rt_61370.t ................. ok   
t/rt_62033.t ................. ok   
t/rt_63550.t ................. ok   
t/rt_78838.t ................. ok   
t/rt_79190.t ................. ok   
t/rt_79397.t ................. ok   
t/rt_81911.t ................. 1/? 
#   Failed test 'affected from execute update 1'
#   at t/rt_81911.t line 74.
#          got: '0E0'
#     expected: '1'

#   Failed test 'affected from execute update 2'
#   at t/rt_81911.t line 82.
#          got: '1'
#     expected: '2'
# Looks like you failed 2 tests of 12.
t/rt_81911.t ................. Dubious, test returned 2 (wstat 512, 0x200)
Failed 2/12 subtests 
t/rt_null_nvarchar.t ......... ok   
t/sql_type_cast.t ............ ok     

Test Summary Report
-------------------
t/02simple.t               (Wstat: 256 Tests: 66 Failed: 1)
  Failed test:  3
  Non-zero exit status: 1
t/rt_81911.t               (Wstat: 512 Tests: 12 Failed: 2)
  Failed tests:  8, 10
  Non-zero exit status: 2
Files=42, Tests=1637,  8 wallclock secs ( 0.57 usr  0.07 sys +  3.24 cusr  0.68 csys =  4.56 CPU)
Result: FAIL
Failed 2/42 test programs. 3/1637 subtests failed.
make: *** [Makefile:1016: test_dynamic] Error 255

make MSSQL Query Notification support an FH

FH might not be the best option either, a callback might work too. The idea is that it would be awesome if one could write some event based code and have ODBC trigger events when data is available.

Data damage when inserting or fetching

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.

upload 1.62_1 to CPAN

Please upload DBD::ODBC 1.62_1 to CPAN so that downstream redistributors like Debian pick it up.

It also contains some fixes/enhancements that may be useful to some users.

add git tags for all releases in Changes file

The git tags are missing a lot of releases that are mentioned in the Changes file. It would be good to have git tags for at least the releases since version 1.43.

$ diff -u <(grep -oE '^[0-9._]+' Changes  | sort -u) <(git tag | sort -u | sed s/DBD-ODBC-//)  | sed -nE 's/^-([0-9])/\1/p'
0.17
0.18
0.19
0.20
0.21
0.22
0.24
0.25
0.26
0.27
0.29
0.30
0.31
0.32
0.33_1
0.33_2
0.33_3
0.34
0.35
0.36
0.37
0.38
0.40
0.41
0.42
0.43
0.45_10
0.45_11
0.45_12
0.45_13
0.45_14
0.45_15
0.45_16
0.45_17
0.45_18
0.45_2
0.45_3
0.45_4
0.45_5
0.45_6
0.45_7
0.45_8
0.45_9
1.09
1.15_2
1.17_1
1.17_3
1.18_1
1.18_2
1.18_4
1.21
1.21_1
1.22_1
1.22_3
1.23
1.23_1
1.23_2
1.23_3
1.23_4
1.23_5
1.24_1
1.24_2
1.24_3
1.24_4
1.24_5
1.24_6
1.25
1.26_3
1.28_5
1.30_2
1.30_3
1.30_4
1.30_5
1.30_6
1.30_7
1.32_1
1.32_2
1.32_3
1.32_4
1.32_5
1.33
1.34_1
1.34_2
1.34_3
1.34_4
1.34_5
1.34_6
1.34_7
1.35
1.36_1
1.38_2
1.40_2
1.40_3
1.42_0
1.42_1
1.42_2
1.42_3
1.42_4
1.42_5
1.44_1
1.44_2
1.44_3
1.44_4
1.45
1.46_1
1.46_2
1.47
1.48
1.49_1
1.49_2
1.49_3
1.49_4
1.50
1.51_1
1.51_2
1.51_3
1.51_4
1.52
1.53_1
1.53_2
1.56
1.57
1.58
1.59
1.60
1.61
1.62_1

odbcconnection Trace emits Password

While running diagnostics as requested for #8, I noticed that odbcconnection tracing emits the password in plain text. Example:

use DBD::ODBC;
DBI->trace(DBD::ODBC->parse_trace_flags('odbcconnection'));
my $dsn = 'dbi:ODBC:Server=example.snowflakecomputing.com;Driver=Snowflake';
my $dbh = DBI->connect($dsn, 'sqitch', 'HIDE ME!', {
    PrintError        => 0,
    RaiseError        => 1,
    AutoCommit        => 1,
    odbc_utf8_on      => 1,
});

The output:

non-Unicode login6_sv
dbd_db_login6
    SQLDriverConnect 'Server=example.snowflakecomputing.com;Driver=Snowflake;UID=sqitch;PWD=HIDE ME!', 'sqitch', 'xxxx'

So it does the right thing for the password argument to connect, but its inclusion in the ODBC DSN is unfortunate.

odbc_utf8_on Not Working with Snowflake

I'm using DBD::ODBC to connect to Snowflake. Snowflake supports UTF-8 encoding only. I'm currently using DBD::ODBC v1.58. On Linux, it's built against unixODBC 2.3.1, and on my Mac against iODBC 3.52.12. In neither case is odbc_has_unicode true.

Using DBD::ODBC to insert UTF-8 encoded strings with the utf-8 flag works fine (I can fetch them in the Snowflake web interface and they're properly UTF-8 encoded). However, even with the odbc_utf8_on flag enabled, strings fetched from the database, while encoded in UTF-8, do not have the UTF-8 flag turned on:

#!/usr/bin/env perl

use v5.20;
use warnings;
use utf8;
use DBI;
use Encode;

my $dsn = 'dbi:ODBC:DSN=snowflake';
my $dbh = DBI->connect($dsn, 'dwheeler', '******', {
    PrintError        => 0,
    RaiseError        => 1,
    AutoCommit        => 1,
    odbc_utf8_on      => 1,
});

END { $dbh->disconnect if $dbh }

$dbh->do('USE DATABASE dwheeler');
$dbh->do('USE WAREHOUSE dwheeler');
$dbh->do('CREATE SCHEMA IF NOT EXISTS try');
$dbh->do('CREATE TEMPORARY TABLE try.stuff (string TEXT)');
my $sth = $dbh->prepare('INSERT INTO try.stuff VALUES (?)');
$sth->execute('Marge N. O’Vera');

my $str = $dbh->selectcol_arrayref('SELECT string FROM try.stuff')->[0];
say 'String is ', (utf8::valid($str) ? '' : ' not '), 'valid UTF-8';
say 'UTF8 flag is ', Encode::is_utf8($str) ? 'on' : 'off';

Output:

String is valid UTF-8
UTF8 flag is off

What might be preventing odbc_utf8_on from turning the flag on for all strings?

DBD::ODBC no longer on CPAN

1.57 was released, but then removed. So, there isn't a current indexed version out there on CPAN. Can you re-upload 1.57 or increment and release a 1.58 please?

Thanks,
Chase