view release on metacpan or search on metacpan
t/lib/DBICTest.pm view on Meta::CPAN
my $dbuser = $args{"user"} || '';
my $dbpass = $args{"pass"} || '';
my $schema;
my @connect_info = ($dsn, $dbuser, $dbpass, { AutoCommit => 1, sqlite_unicode => 1 });
if ($args{compose_connection}) {
$schema = DBICTest::Schema->compose_connection(
'DBICTest', @connect_info
);
view release on metacpan or search on metacpan
t/lib/I18NTest.pm view on Meta::CPAN
$schema_class ||= 'I18NTest::Schema';
eval "require $schema_class"
or die "failed to require $schema_class: $@";
my $schema = $schema_class->connect("DBI:SQLite::memory:",'','', { sqlite_unicode => 1 })
or die "failed to connect to DBI:SQLite::memory: ($schema_class)";
$schema->deploy;
return $schema;
}
view release on metacpan or search on metacpan
t/testlib/TestDB.pm view on Meta::CPAN
my $dbh = DBI->connect(
"dbi:SQLite:dbname=:memory:",
"", "",
{ RaiseError => 1,
sqlite_unicode => 1,
}
);
$dbh->do( "
CREATE TABLE test (
view release on metacpan or search on metacpan
t/lib/DBICTest.pm view on Meta::CPAN
my $dsn = $ENV{"DBICTEST_DSN"} || "dbi:SQLite:${db_file}";
my $dbuser = $ENV{"DBICTEST_DBUSER"} || '';
my $dbpass = $ENV{"DBICTEST_DBPASS"} || '';
my @connect_info = ($dsn, $dbuser, $dbpass, { AutoCommit => 1, sqlite_unicode => 1, %args });
return @connect_info;
}
sub init_schema {
view release on metacpan or search on metacpan
t/00-report-prereqs.t
t/basic.t
t/lib/TestSchema.pm
t/lib/TestSchema.sql
t/lib/TestSchema/Result/Foo.pm
t/unicode.t
xt/author/00-compile.t
xt/author/changes_has_content.t
xt/author/clean-namespaces.t
xt/author/eol.t
xt/author/kwalitee.t
view release on metacpan or search on metacpan
lib/DBIx/Class/ResultDDL.pm view on Meta::CPAN
# Same API for the others
nchar ... data_type => 'nchar' ...
bit ... data_type => 'bit' ...
C<nchar> (SQL Server unicode char array) has an identical API but
returns C<< data_type => 'nchar' >>
Note that Postgres allows C<"bit"> to have a size, like C<char($size)> but SQL Server
uses C<"bit"> only to represent a single bit.
lib/DBIx/Class/ResultDDL.pm view on Meta::CPAN
# MySQL specific variants:
tinytext data_type => 'tinytext', size => 0xFF
mediumtext data_type => 'mediumtext', size => 0xFFFFFF
longtext data_type => 'longtext', size => 0xFFFFFFFF
# SQL Server unicode variant:
ntext data_type => 'ntext', size => 0x3FFFFFFF
ntext($size) data_type => 'ntext', size => $size
See MySQL notes in C<blob>. For SQL Server, you might want C<ntext> or C<< nvarchar(MAX) >>
instead. Postgres does not use a size, and allows arrays of this type.
view release on metacpan or search on metacpan
lib/DBIx/Class/Schema/Loader/DBI/InterBase.pm view on Meta::CPAN
if ($sub_type_name eq 'BINARY') {
$info->{data_type} = 'blob';
}
elsif ($sub_type_name eq 'TEXT') {
if (defined $char_set_id && $char_set_id == 3) {
$info->{data_type} = 'blob sub_type text character set unicode_fss';
}
else {
$info->{data_type} = 'blob sub_type text';
}
}
lib/DBIx/Class/Schema/Loader/DBI/InterBase.pm view on Meta::CPAN
if ($data_type =~ /^(?:char|varchar)\z/) {
$info->{size} = $char_length;
if (defined $char_set_id && $char_set_id == 3) {
$info->{data_type} .= '(x) character set unicode_fss';
}
}
elsif ($data_type !~ /^(?:numeric|decimal)\z/) {
delete $info->{size};
}
view release on metacpan or search on metacpan
inc/Pod/Markdown.pm view on Meta::CPAN
$section =~ s/^\s+//;
$section =~ s/\s+$//;
$section =~ tr/ /_/;
$section =~ tr/\x00-\x1F\x80-\x9F//d if 'A' eq chr(65); # drop crazy characters
#$section = $self->unicode_escape_url($section);
# unicode_escape_url {
$section =~ s/([^\x00-\xFF])/'('.ord($1).')'/eg;
# Turn char 1234 into "(1234)"
# }
$section = '_' unless length $section;
view release on metacpan or search on metacpan
t/lib/Role/MySQL.pm view on Meta::CPAN
my $self = shift;
no warnings 'once'; # prevent: "Test::mysqld::errstr" used only once
my $mysqld = Test::mysqld->new(
my_cnf => {
'character-set-server' => 'utf8',
'collation-server' => 'utf8_unicode_ci',
'skip-networking' => '',
}
) or die $Test::mysqld::errstr;
return $mysqld;
}
view release on metacpan or search on metacpan
0.1.3
* Pass plain "BLOB" type as binary.
0.1.2
* Fix breaking of non-ASCII unicode in previous release.
0.1.1
* Pass BLOBs correctly.
* Make Kwalitee happier.
view release on metacpan or search on metacpan
{
{
my $dbi = DBIx::Custom->connect(
dsn => 'dbi:SQLite:dbname=:memory:',
option => {
$DBD::SQLite::VERSION > 1.26 ? (sqlite_unicode => 1) : (unicode => 1)
}
);
my $binary = pack("I3", 1, 2, 3);
eval { $dbi->execute('drop table table1') };
$dbi->execute('create table table1(key1, key2)');
}
{
my $dbi = DBIx::Custom->connect(
dsn => 'dbi:SQLite:dbname=:memory:',
option => {
$DBD::SQLite::VERSION > 1.26 ? (sqlite_unicode => 1) : (unicode => 1)
}
);
my $binary = pack("I3", 1, 2, 3);
eval { $dbi->execute('drop table table1') };
$dbi->execute('create table table1(key1, key2)');
view release on metacpan or search on metacpan
Sybase => 'server', ODBC => '', XBase => '');
my %kwportmap = (mysql => 'port', Pg => 'port');
my %kwutf8map = (mysql => 'mysql_enable_utf8',
Pg => 'pg_enable_utf8',
SQLite => 'sqlite_unicode',
Sybase => 'syb_enable_utf8');
# Whether the DBMS supports transactions
my %transactmap = (mSQL => 0, mysql => 0, Pg => 1, Sybase => 'server',
ODBC => 0, XBase => 0);
view release on metacpan or search on metacpan
t/02_utf8.t view on Meta::CPAN
note 'Text::CSV';
note sprintf(" %-${_column_width}s : %s", 'VERSION', Text::CSV->VERSION);
note sprintf(" %-${_column_width}s : %s", 'Backend', Text::CSV->module);
note sprintf(" %-${_column_width}s : %s", 'Backend::VERSION', Text::CSV->version);
my $dbh = DBI->connect("dbi:SQLite::memory:", '', '', {RaiseError => 1, sqlite_unicode => 1}) or die 'cannot connect to db';
$dbh->do(q{
CREATE TABLE item (
id INTEGER PRIMARY KEY,
name VARCHAR(255)
);
view release on metacpan or search on metacpan
pad_sv|||
pad_swipe|||
pad_tidy|||
pad_undef|||
parse_body|||
parse_unicode_opts|||
path_is_absolute|||
peep|||
pending_ident|||
perl_alloc_using|||n
perl_alloc|||n
view release on metacpan or search on metacpan
my $file = shift || ':memory:';
DBI->connect('dbi:SQLite:'.$file,'','',{
RaiseError => 1,
PrintError => 0,
AutoCommit => 1,
sqlite_unicode => 1,
});
}
1;
view release on metacpan or search on metacpan
t/01records.t view on Meta::CPAN
($val,$msg) = $rec->SetName('1234567890123456789012345678901234567890');
ok(!$val, $msg);
is($msg, 'That is already the current value', 'No update for same value');
is($rec->Name, '12345678901234', "Value is the same");
# Test unicode truncation:
my $univalue = "這是個測試";
($val,$msg) = $rec->SetName($univalue.$univalue);
ok($val, $msg) ;
is($rec->Name, '這是個測');
view release on metacpan or search on metacpan
examples/lib/My/App.pm view on Meta::CPAN
my $app = shift;
DBIx::Simple::Class->DEBUG(1);
my $dbix = DBIx::Simple->connect(
"dbi:SQLite:dbname=$ENV{users_HOME}/db.sqlite",
{sqlite_unicode => 1, RaiseError => 1}
) || die $DBI::errstr;
DBIx::Simple::Class->dbix($dbix);
$dbix->query(<<"TAB");
CREATE TABLE IF NOT EXISTS groups(
id INTEGER PRIMARY KEY AUTOINCREMENT,
view release on metacpan or search on metacpan
lib/DBIx/Simple/DataSection.pm view on Meta::CPAN
}
elsif ( $driver_name eq 'mysql' ) {
$self->{dbh}->{mysql_enable_utf8} = 1;
}
elsif ( $driver_name eq 'SQLite' ) {
$self->{dbh}->{unicode} = 1;
}
}
sub connect {
my $self = shift->SUPER::connect(@_);
view release on metacpan or search on metacpan
lib/DBIx/Simplish.pm view on Meta::CPAN
if ($self->_is_mysql) {
$options->{mysql_enable_utf8} = 1 unless exists $options->{mysql_enable_utf8};
$options->{mysql_enable_utf8mb4} = 1 unless exists $options->{mysql_enable_utf8mb4};
} elsif ($self->_is_sqlite) {
$options->{sqlite_use_immediate_transaction} = 1 unless exists $options->{sqlite_use_immediate_transaction};
$options->{sqlite_unicode} = 1 unless exists $options->{sqlite_unicode};
}
my $connector = DBIx::Connector->new(
$self->dsn,
$self->user,
$self->password,
view release on metacpan or search on metacpan
examples/01.pl view on Meta::CPAN
"",
"",
{
PrintError => !!0,
RaiseError => !!1,
sqlite_unicode => !!1,
},
);
};
get_artist_id_by_name do {
view release on metacpan or search on metacpan
lib/DBIx/Struct.pm view on Meta::CPAN
if ($driver eq 'Pg') {
$connect_attrs->{pg_enable_utf8} = 1;
} elsif ($driver eq 'mysql') {
$connect_attrs->{mysql_enable_utf8} = 1;
} elsif ($driver eq 'SQLite') {
$connect_attrs->{sqlite_unicode} = 1;
}
}
}
if (!@$connector_args) {
@$connector_args = ($dsn, $user, $password, $connect_attrs);
view release on metacpan or search on metacpan
lib/DBIx/Sunny.pm view on Meta::CPAN
$attr->{PrintError} = 0;
$attr->{ShowErrorStatement} = 1;
$attr->{AutoInactiveDestroy} = 1;
if ($dsn =~ /^(?i:dbi):SQLite:/) {
$attr->{sqlite_use_immediate_transaction} = 1;
$attr->{sqlite_unicode} = 1 unless exists $attr->{sqlite_unicode};
}
if ($dsn =~ /^(?i:dbi):mysql:/ && ! exists $attr->{mysql_enable_utf8} && ! exists $attr->{mysql_enable_utf8mb4} ) {
$attr->{mysql_enable_utf8} = 1;
}
if ($dsn =~ /^(?i:dbi):Pg:/ && ! exists $attr->{pg_enable_utf8}) {
lib/DBIx/Sunny.pm view on Meta::CPAN
$dbh->{PrintError} = 0;
$dbh->{ShowErrorStatement} = 1;
$dbh->{AutoInactiveDestroy} = 1;
if ($dsn =~ /^dbi:SQLite:/) {
$dbh->{sqlite_use_immediate_transaction} = 1;
$dbh->{sqlite_unicode} = 1 unless exists $attr->{sqlite_unicode};
$dbh->do("PRAGMA journal_mode = WAL");
$dbh->do("PRAGMA synchronous = NORMAL");
}
lib/DBIx/Sunny.pm view on Meta::CPAN
DBIx::Sunny sets AutoInactiveDestroy as true.
=item [SQLite/MySQL/Pg] Auto encode/decode UTF-8
DBIx::Sunny sets sqlite_unicode, mysql_enable_utf8 and pg_enable_utf8 automatically.
=item [SQLite] Performance tuning
DBIx::Sunny sets sqlite_use_immediate_transaction to true, and executes these PRAGMA statements
view release on metacpan or search on metacpan
lib/DBIx/TempDB/Util.pm view on Meta::CPAN
$opt{AutoCommit} //= 1;
$opt{AutoInactiveDestroy} //= 1;
$opt{PrintError} //= 0;
$opt{RaiseError} //= 1;
$opt{sqlite_unicode} //= 1;
return $dsn, "", "", \%opt;
}
sub _on_process_end_double_fork {
view release on metacpan or search on metacpan
lib/DBIx/Wrapper.pm view on Meta::CPAN
for (1 .. 4) {
_parse_json_next_char();
if ($char !~ /[0-9A-Fa-f]/) {
# error -- bad unicode specifier
if ($json_warn) {
warn "bad unicode specifier at pos $looking_at, char=$char";
}
last;
}
$u .= $char;
}
view release on metacpan or search on metacpan
XMLServer.pm view on Meta::CPAN
return substr($text, 0, pos $text), substr($text, pos $text);
}
BEGIN {
# This hack is because Perl 5.6.1 appears to be buggy and not
# allow unicode character properties to be declared in a package
# pther than main.
our $property_package = $ lt v5.8 ? 'main' : 'DBIx::XMLServer::Request';
eval <<END_PROPERTIES;
package $property_package;
view release on metacpan or search on metacpan
pad_sv||5.011000|
pad_swipe|||
pad_tidy|||
pad_undef|||
parse_body|||
parse_unicode_opts|||
parser_dup|||
parser_free|||
path_is_absolute|||n
peep|||
pending_Slabs_to_ro|||
#ifndef PERL_PV_PRETTY_REGPROP
# define PERL_PV_PRETTY_REGPROP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_LTGT|PERL_PV_ESCAPE_RE
#endif
/* Hint: pv_escape
* Note that unicode functionality is only backported to
* those perl versions that support it. For older perl
* versions, the implementation will fall back to bytes.
*/
#ifndef pv_escape
view release on metacpan or search on metacpan
lib/DBM/Deep/Engine/File.pm view on Meta::CPAN
if ( $feature eq 'transactions' ) {
return $self->num_txns > 1;
}
return 1 if $feature eq 'singletons';
return 1 if $feature eq 'unicode';
return;
}
sub db_version {
return $_[0]{v} == 3 ? '1.0003' : 2;
view release on metacpan or search on metacpan
parser_free|5.009005||Viu
parser_free_nexttoke_ops|5.017006||Viu
parse_stmtseq|5.013006|5.013006|x
parse_subsignature|5.031003|5.031003|x
parse_termexpr|5.013008|5.013008|x
parse_unicode_opts|5.008001||Viu
parse_uniprop_string|5.027011||Viu
PATCHLEVEL|5.003007||Viu
path_is_searchable|5.019001||Vniu
Pause|5.003007||Viu
pause|5.005000||Viu
PL_tokenbuf||5.003007|ponu
PL_top_env|5.005000||Viu
PL_toptarget|5.005000||Viu
PL_TR_SPECIAL_HANDLING_UTF8|5.031006||Viu
PL_underlying_numeric_obj|5.027009||Viu
PL_unicode|5.008001||Viu
PL_unitcheckav|5.009005||Viu
PL_unitcheckav_save|5.009005||Viu
PL_unlockhook|5.007003||Viu
PL_unsafe|5.005000||Viu
PL_UpperLatin1|5.019005||Viu
#ifndef PERL_PV_PRETTY_REGPROP
# define PERL_PV_PRETTY_REGPROP PERL_PV_PRETTY_ELLIPSES|PERL_PV_PRETTY_LTGT|PERL_PV_ESCAPE_RE
#endif
/* Hint: pv_escape
* Note that unicode functionality is only backported to
* those perl versions that support it. For older perl
* versions, the implementation will fall back to bytes.
*/
#ifndef pv_escape