array.pm

普通的ETL工具

	use Class::STL::ClassMembers::Constructor;
	sub translate
	{
		my $self = shift;
		my $c = $self->SUPER::translate(@_);
		foreach (@_) { $_ = "&to_array($_)" unless (/^@/); }
		$c->code("(sort{ \$a <=> \$b }grep(/^[\\d|\\.|\\-]+\$/, (@{[ join(',', @_) ]})))[0] || ''");
		return $c;
	}
}
# ----------------------------------------------------------------------------------------------------
{
	package ETL::Pequel3::Type::Macros::ArrMaxNumeric;
	use base qw(ETL::Pequel3::Type::Macros::Array::Abstract);
	use Class::STL::ClassMembers 
		Class::STL::ClassMembers::DataMember->new(name => 'description', default => 'Returns the element value in array I<expr> with the highest numeric value.'),
		Class::STL::ClassMembers::DataMember->new(name => 'usage', default => '&arr_max_numeric(E<lt> I<expr> E<gt>)'),
		Class::STL::ClassMembers::DataMember->new(name => 'name', default => 'arr_max_numeric');
	use Class::STL::ClassMembers::Constructor;
	sub translate
	{
		my $self = shift;
		my $c = $self->SUPER::translate(@_);
		foreach (@_) { $_ = "&to_array($_)" unless (/^@/); }
		$c->code("(sort{ \$a <=> \$b }grep(/^[\\d|\\.|\\-]+\$/, (@{[ join(',', @_) ]})))[-1] || ''");
		return $c;
	}
}
# ----------------------------------------------------------------------------------------------------
{
	package ETL::Pequel3::Type::Macros::ArrMin;
	use base qw(ETL::Pequel3::Type::Macros::Array::Abstract);
	use Class::STL::ClassMembers 
		Class::STL::ClassMembers::DataMember->new(name => 'description', default => 'Returns the element value in array I<expr> with the lowest value.'),
		Class::STL::ClassMembers::DataMember->new(name => 'usage', default => '&arr_min(E<lt> I<expr> E<gt>)'),
		Class::STL::ClassMembers::DataMember->new(name => 'name', default => 'arr_min');
	use Class::STL::ClassMembers::Constructor;
	sub translate
	{
		my $self = shift;
		my $c = $self->SUPER::translate(@_);
		foreach (@_) { $_ = "&to_array($_)" unless (/^@/); }
		$c->code("(sort (@{[ join(',', @_) ]}))[0] || ''");
		return $c;
	}
}
# ----------------------------------------------------------------------------------------------------
{
	package ETL::Pequel3::Type::Macros::ArrMax;
	use base qw(ETL::Pequel3::Type::Macros::Array::Abstract);
	use Class::STL::ClassMembers 
		Class::STL::ClassMembers::DataMember->new(name => 'description', default => 'Returns the element value in array I<expr> with the highest value.'),
		Class::STL::ClassMembers::DataMember->new(name => 'usage', default => '&arr_max(E<lt> I<expr> E<gt>)'),
		Class::STL::ClassMembers::DataMember->new(name => 'name', default => 'arr_max');
	use Class::STL::ClassMembers::Constructor;
	sub translate
	{
		my $self = shift;
		my $c = $self->SUPER::translate(@_);
		foreach (@_) { $_ = "&to_array($_)" unless (/^@/); }
		$c->code("(sort (@{[ join(',', @_) ]}))[-1] || ''");
		return $c;
	}
}
# ----------------------------------------------------------------------------------------------------
{
	package ETL::Pequel3::Type::Macros::ArrLookup;
	use base qw(ETL::Pequel3::Type::Macros::Array::Abstract);
	use Class::STL::ClassMembers 
		Class::STL::ClassMembers::DataMember->new(name => 'description', default => 'Returns the I<count> of elements in array I<expr> that match the reqular expression in I<patt>.'),
		Class::STL::ClassMembers::DataMember->new(name => 'usage', default => '&arr_lookup(E<lt> I<patt> E<gt>, E<lt> I<expr> E<gt>)'),
		Class::STL::ClassMembers::DataMember->new(name => 'name', default => 'arr_lookup');
	use Class::STL::ClassMembers::Constructor;
	sub translate # pattern, field [, field ...]
	{
		my $self = shift;
		my $c = $self->SUPER::translate(@_);
		my $patt = shift;
		foreach (@_) { $_ = "&to_array($_)" unless (/^@/); }
		$patt =~ s/['"]//g;
		$c->code("grep(/^$patt\$/, @{[ join(',', @_) ]})");
		return $c;
	}
}
# ----------------------------------------------------------------------------------------------------
{
	package ETL::Pequel3::Type::Macros::ArrUnpack;
	use base qw(ETL::Pequel3::Type::Macros::Array::Abstract);
	use Class::STL::ClassMembers 
		Class::STL::ClassMembers::DataMember->new(name => 'description', default => 'Use the pack-format in I<format> to unpack the value in I<expr> to produce an array string with elements delimited by the I<default_list_delimiter> property.'),
		Class::STL::ClassMembers::DataMember->new(name => 'usage', default => '&arr_unpack(E<lt> I<format> E<gt>, E<lt> I<expr> E<gt>)'),
		Class::STL::ClassMembers::DataMember->new(name => 'name', default => 'arr_unpack');
	use Class::STL::ClassMembers::Constructor;
	sub translate # format, packed_str
	{
		my $self = shift;
		my $c = $self->SUPER::translate(@_);
		my $delim = $self->configuration()->default_list_delimiter();
		$#_ > 1 
			? $c->code("join('$delim', unpack($_[0], join('', @{[ join(',', @_[1..$#_]) ]}) ) )")
			: $c->code("join('$delim', unpack($_[0], $_[1] ) )");
		return $c;
	}
}
# ----------------------------------------------------------------------------------------------------
{
	package ETL::Pequel3::Type::Macros::ArrPack;
	use base qw(ETL::Pequel3::Type::Macros::Array::Abstract);
	use Class::STL::ClassMembers 
		Class::STL::ClassMembers::DataMember->new(name => 'description', default => 'Use the pack-format in I<format> to pack the array in I<expr> to produce a string containing the packed value.'),
		Class::STL::ClassMembers::DataMember->new(name => 'usage', default => '&arr_pack(E<lt> I<format> E<gt>, E<lt> I<expr> E<gt>)'),
		Class::STL::ClassMembers::DataMember->new(name => 'name', default => 'arr_pack');
	use Class::STL::ClassMembers::Constructor;
	sub translate # format, array
	{
		my $self = shift;
		my $c = $self->SUPER::translate(@_);
		my @orig = @_[1..$#_];
		foreach (@_[1..$#_]) { $_ = "&to_array($_)" unless (/^@/); }
		$_[0] =~ s/['"]//g;
		$_[0] =~ /^\[(.*)\]$/
			? $c->code("pack('$1' x &arr_size(@orig), @{[ join(',', @_[1..$#_]) ]})")
			: $c->code("pack('$_[0]', @{[ join(',', @_[1..$#_]) ]})");
		return $c;
	}
}
# ----------------------------------------------------------------------------------------------------
{
	package ETL::Pequel3::Type::Macros::ArrShift;
	use base qw(ETL::Pequel3::Type::Macros::Array::Abstract);
	use Class::STL::ClassMembers 
		Class::STL::ClassMembers::DataMember->new(name => 'name', default => 'arr_shift');
	use Class::STL::ClassMembers::Constructor;
	sub code_init_global
	{
		my $self = shift;
		my $c = $self->SUPER::code_init_global(@_);
		$c->code("my  \%_ARR_SHIFT; # \&$self->name() ]}()");
		return $c;
	}
	sub translate
	{
		my $self = shift;
		my $c = $self->SUPER::translate(@_);
		$c->code("(@{[ join(',', @_) ]})[\$_ARR_SHIFT{_@{[ $_[0] =~ /^@/ ? substr($_[0], 1) : $_[0] ]}}++]");
		return $c;
	}
}
# ----------------------------------------------------------------------------------------------------
{
	package ETL::Pequel3::Type::Macros::ArrPop;
	use base qw(ETL::Pequel3::Type::Macros::Array::Abstract);
	use Class::STL::ClassMembers 
		Class::STL::ClassMembers::DataMember->new(name => 'name', default => 'arr_pop');
	use Class::STL::ClassMembers::Constructor;
	sub code_init_global
	{
		my $self = shift;
		my $c = $self->SUPER::code_init_global(@_);
		$c->code("my  \%_ARR_POP; # \&$self->name() ]}()");
		return $c;
	}
	sub translate
	{
		my $self = shift;
		my $c = $self->SUPER::translate();
		$c->code("(reverse (@{[ join(',', @_) ]}))[\$_ARR_POP{_@{[ $_[0] =~ /^@/ ? substr($_[0], 1) : $_[0] ]}}++]");
		return $c;
	}
}
# ----------------------------------------------------------------------------------------------------
{
	package ETL::Pequel3::Type::Macros::ArrPush;
	use base qw(ETL::Pequel3::Type::Macros::Array::Abstract);
	use Class::STL::ClassMembers 
		Class::STL::ClassMembers::DataMember->new(name => 'name', default => 'arr_push');
	use Class::STL::ClassMembers::Constructor;
	sub translate
	{
		my $self = shift;
		my $c = $self->SUPER::translate(@_);
		$c->code("push($_[0])");
		return $c;
	}
}
# ----------------------------------------------------------------------------------------------------
{
	package ETL::Pequel3::Type::Macros::Array;
	use ETL::Pequel3::Type::Extension;
	use base qw(ETL::Pequel3::Type::Extension::Abstract);
	use Class::STL::ClassMembers;
	use Class::STL::ClassMembers::SingletonConstructor;
	sub new_extra
	{
		my $self = shift;
		$self->catalogue()->macros()->push_front(
        	ETL::Pequel3::Type::Macros::ToArray->_new(),
        	ETL::Pequel3::Type::Macros::ArrSize->_new(),
        	ETL::Pequel3::Type::Macros::ArrSort->_new(),
        	ETL::Pequel3::Type::Macros::ArrSortNumeric->_new(),
        	ETL::Pequel3::Type::Macros::ArrReverse->_new(),
        	ETL::Pequel3::Type::Macros::ArrValuesUniq->_new(),
        	ETL::Pequel3::Type::Macros::ArrSum->_new(),
        	ETL::Pequel3::Type::Macros::ArrAvg->_new(),
        	ETL::Pequel3::Type::Macros::ArrMean->_new(),
        	ETL::Pequel3::Type::Macros::ArrFront->_new(),
        	ETL::Pequel3::Type::Macros::ArrBack->_new(),
        	ETL::Pequel3::Type::Macros::ArrFirst->_new(),
        	ETL::Pequel3::Type::Macros::ArrLast->_new(),
        	ETL::Pequel3::Type::Macros::ArrMin->_new(),
        	ETL::Pequel3::Type::Macros::ArrMax->_new(),
        	ETL::Pequel3::Type::Macros::ArrMinNumeric->_new(),
        	ETL::Pequel3::Type::Macros::ArrMaxNumeric->_new(),
        	ETL::Pequel3::Type::Macros::ArrLookup->_new(),
        	ETL::Pequel3::Type::Macros::ArrUnpack->_new(),
        	ETL::Pequel3::Type::Macros::ArrPack->_new(),
#>	       	ETL::Pequel3::Type::Macros::ArrSetAnd->new(),
#>	       	ETL::Pequel3::Type::Macros::ArrSetOr->new(),
#>	       	ETL::Pequel3::Type::Macros::ArrSetXor->new(),
#?        	ETL::Pequel3::Type::Macros::ArrShift->new(),
#?        	ETL::Pequel3::Type::Macros::ArrPop->new(),
#?        	ETL::Pequel3::Type::Macros::ArrPush->new(),
#>			ArrResize(array, newsize) -- truncate array
#>			ArrShift(array, n) -- This function returns a new valarray object whose elements have all been rotated n places to left or right with respect to self. A positive value of n shifts the elements to the left, a negative value to the right. For example, applying shift(2) to an array corresponding to [3,4,5,6] results in [5,6,3,4], and applying shift(-1) to [3,4,5,6] results in [6,3,4,5].
#>			ArrRotate -- alternate name for ArrShift
#>			ArrApply(<macro_name>, array) -- returns array with all elements applied to <macro_name>
#>			ArrBindFirst(<macro_name>, array, arg), ArrBindSecond
#<			ETL::Pequel3::Type::Macros::ArrPeek->new,			# return last element in array
#>			ETL::Pequel3::Type::Macros::ArrAvgDistinct->new,	# return average for distinct values in array
#>			ETL::Pequel3::Type::Macros::ArrSumDistinct->new,	# return sum for distinct values in array
#>			ETL::Pequel3::Type::Macros::ArrSelect->new,	# or ArrFilter: &arr_select(<field>, <value|/regex/>)
#>			ETL::Pequel3::Type::Macros::ArrDistinct->new,		# return count of distinct values
#>			ETL::Pequel3::Type::Macros::ArrMedian->new,
#>			ETL::Pequel3::Type::Macros::ArrVariance->new,
#>			ETL::Pequel3::Type::Macros::ArrStddev->new,
#>			ETL::Pequel3::Type::Macros::ArrRange->new,
#>			ETL::Pequel3::Type::Macros::ArrMode->new,
#>			ETL::Pequel3::Type::Macros::ArrLongest->new,		# return longest string in array
#>			ETL::Pequel3::Type::Macros::ArrShortest->new,		# return longest string in array
#>			ETL::Pequel3::Type::Macros::ArrWidthBucket,
#>			ETL::Pequel3::Type::Macros::ArrNtile,
#>			ETL::Pequel3::Type::Macros::ArrRank,
#>			ETL::Pequel3::Type::Macros::ArrCorr,
#>			ETL::Pequel3::Type::Macros::ArrCumeDist,
#>			ETL::Pequel3::Type::Macros::ArrCovarPop,
#>			ETL::Pequel3::Type::Macros::ArrCovarSamp,
#>			ETL::Pequel3::Type::Macros::ArrPercentRank,
#>			ETL::Pequel3::Type::Macros::ArrPercentileCont,
#>			ETL::Pequel3::Type::Macros::ArrPercentileDisc,
		);
		return $self;
	}
}
# ----------------------------------------------------------------------------------------------------
1;