File Coverage

blib/lib/Mock/Data/Plugin/SQLTypes.pm

Criterion	Covered	Total	%
statement	77	86	89.5
branch	48	68	70.5
condition	19	47	40.4
subroutine	30	32	93.7
pod	13	14	92.8
total	187	247	75.7

package Mock::Data::Plugin::SQLTypes;
use Mock::Data::Plugin -exporter_setup => 1;
use Mock::Data::Plugin::Net qw( cidr macaddr ), 'ipv4', { -as => 'inet' };
use Mock::Data::Plugin::Number qw( integer decimal float sequence uuid byte );
use Mock::Data::Plugin::Text 'join' => { -as => 'text_join' }, 'words';
our %type_generators= map +($_ => 1), qw(
	integer tinyint smallint bigint
	sequence serial smallserial bigserial
	numeric decimal
	float float4 real float8 double double_precision
	bit bool boolean
	varchar char nvarchar
	text tinytext mediumtext longtext ntext
	blob tinyblob mediumblob longblob bytea
	varbinary binary
	date datetime datetime2 datetimeoffset timestamp
	datetime_with_time_zone datetime_without_time_zone
	json jsonb
	uuid inet cidr macaddr
);
export(keys %type_generators);

# ABSTRACT: Collection of generators that produce data matching a SQL column type
our $VERSION = '0.04'; # VERSION


sub apply_mockdata_plugin {
	my ($class, $mock)= @_;
	$mock->load_plugin('Text')->add_generators(
		map +("SQL::$_" => $class->can($_)), keys %type_generators
	);
}


sub generator_for_type {
	my ($mock, $type)= @_;
	$type =~ s/\s+/_/g;
	my $gen= $mock->generators->{$type} // $mock->generators->{"SQL::$type"}
		// $type_generators{$type} && Mock::Data::GeneratorSub->new(__PACKAGE__->can($type));
	# TODO: check for complex things like postgres arrays
	return $gen;
}


sub tinyint {
	my $mock= shift;
	my $params= ref $_[0] eq 'HASH'? shift : undef;
	integer($mock, { $params? %$params : (), bits => 8 }, @_);
}

sub smallint {
	my $mock= shift;
	my $params= ref $_[0] eq 'HASH'? shift : undef;
	integer($mock, { $params? %$params : (), bits => 16 }, @_);
}

sub bigint {
	my $mock= shift;
	my $params= ref $_[0] eq 'HASH'? shift : undef;
	integer($mock, { $params? %$params : (), bits => 64 }, @_);
}


BEGIN { *bigserial= *smallserial= *serial= *sequence; }


BEGIN { *numeric= *decimal; }


BEGIN { *real= *float4= *float; }

sub double {
	my $mock= shift;
	my $params= ref $_[0] eq 'HASH'? shift : undef;
	float($mock, { bits => 53, $params? %$params : () }, @_);
}

BEGIN { *float8= *double_precision= *double; }


sub bit {
	int rand 2;
}
BEGIN { *bool= *boolean= *bit; }


sub varchar {
	my $mock= shift;
	my $params= ref $_[0] eq 'HASH'? shift : undef;
	my $size= shift // ($params? $params->{size} : undef) // 16;
	my $size_weight= ($params? $params->{size_weight} : undef) // \&_default_size_weight;
	my $source= ($params? $params->{source} : undef);
	if (defined $source && !ref $source) {
		Carp::croak("No generator '$source' available")
			unless $mock->generators->{$source};
	} else {
		$source= $mock->generators->{word}? 'word' : \&word;
	}
	return text_join($mock, {
		source => $source,
		max_len => $size,
		len => $size_weight->($size),
	});
}
sub _default_size_weight {
	my $size= shift;
	$size <= 32? int rand($size+1)
		: int rand(100)? int rand(33)
		: 33+int rand($size-31)
}



BEGIN { *nvarchar= *varchar; }

sub text {
	my $mock= shift;
	my $params= ref $_[0] eq 'HASH'? shift : undef;
	varchar($mock, { size => 256, ($params? %$params : ()) }, @_);
}

BEGIN { *ntext= *tinytext= *mediumtext= *longtext= *text; }


sub char {
	my $mock= shift;
	my $params= ref $_[0] eq 'HASH'? shift : undef;
	my $size= @_? shift : ($params? $params->{size} : undef) // 1;
	my $str= varchar($mock, ($params? $params : ()), $size);
	$str .= ' 'x($size - length $str) if length $str < $size;
	return $str;
}


sub _epoch_to_iso8601 {
	my @t= localtime(shift);
	return sprintf "%04d-%02d-%02d %02d:%02d:%02d", $t[5]+1900, $t[4]+1, @t[3,2,1,0];
}
sub _iso8601_to_epoch {
	my $str= shift;
	$str =~ /^
		(\d{4}) - (\d{2}) - (\d{2})
		(?: [T ] (\d{2}) : (\d{2})  # maybe time
			(?: :(\d{2})            # maybe seconds
				(?: \. \d+ )?       # ignore milliseconds
			)?
			(?: Z | [-+ ][:\d]+ )?  # ignore timezone or Z
		)?
	/x or Carp::croak("Invalid date '$str'.  Expecting format YYYY-MM-DD[ HH:MM:SS[.SSS][TZ]]");
	require POSIX;
	return POSIX::mktime($6||0, $5||0, $4||0, $3, $2-1, $1-1900);
}

sub datetime {
	my $mock= shift;
	my $params= ref $_[0] eq 'HASH'? shift : undef;
	my $before= $params && $params->{before}? _iso8601_to_epoch($params->{before}) : (time - 86400);
	my $after=  $params && $params->{after}?  _iso8601_to_epoch($params->{after})  : (time - int(10*365.25*86400));
	_epoch_to_iso8601($after + int rand($before-$after));
}

sub date {
	substr(datetime(@_), 0, 10)
}

BEGIN {
	*timestamp= *datetime2= *datetime_without_time_zone= *datetime;
	*datetimeoffset= *datetime_with_time_zone= *datetime;
}


sub blob {
	my $mock= shift;
	my $params= ref $_[0] eq 'HASH'? shift : undef;
	my $size= shift // ($params? $params->{size} : undef) // 256;
	byte($mock, $size);
}

BEGIN { *tinyblob= *mediumblob= *longblob= *bytea= *binary= *varbinary= *blob; }


our $json;
sub _json_encoder {
	$json //= do {
		local $@;
		my $mod= eval { require JSON::MaybeXS; 'JSON::MaybeXS' }
			  || eval { require JSON; 'JSON' }
			  || eval { require JSON::PP; 'JSON::PP' }
			or Carp::croak("No JSON module found.  This must be installed for the SQL::json generator.");
		$mod->new->canonical->ascii
	};
}

sub json {
	my $mock= shift;
	my $params= ref $_[0] eq 'HASH'? shift : undef;
	my $data= shift // ($params? $params->{data} : undef);
	return defined $data? _json_encoder->encode($data) : '{}';
}

BEGIN { *jsonb= *json; }


1;

__END__