table.pm

普通的ETL工具

# ----------------------------------------------------------------------------------------------------
{	
	package ETL::Pequel3::Type::Table::DbiDynamic;
	use base qw(ETL::Pequel3::Type::Table::Dbi::Abstract);
	use Class::STL::ClassMembers
		Class::STL::ClassMembers::DataMember->new(name => 'description', default => "The data for this table type is loaded from an external F<dbi> I<dataset>. The data for a dynamic type table is loaded at run-time, that is, when the I<generated> program executes."),
		Class::STL::ClassMembers::DataMember->new(name => 'name', default => 'dbi_dynamic');
	use Class::STL::ClassMembers::Constructor;
	sub code_load_table
	{
		my $self = shift;
		my $c = shift || ETL::Pequel3::CodeStyler::Program->new();
		$c->divider();
		$self->code_display_info($c, "@{[ __PACKAGE__ ]}");
		$c->open_block("{");
			$c->code("package " . $self->package_name() . ";");
			$c->code("sub @{[ $self->load_function_name() ]}");
			$c->open_block("{");
				$self->input_dataset()->code_init($c);
				$self->catalogue()->code_segments()->verbose_msg()->new(
					target_name => $self->properties()->script_name(),
					user_prog => $c,
					msg_text => "Loading table @{[ $self->name() ]} from @{[ $self->input_dataset()->dsn() ]}..."
				)->prepare() if ($self->configuration()->verbose()); 
				$self->input_dataset()->code_open($c);
				$self->input_dataset()->code_prepare($c);
				$c->newline_off();
				$c->code("my \$@{[ $self->tname() ]} = "); # hash_ref
				$c->newline_on();
				$c->code("\$@{[ $self->input_dataset()->sth_vname() ]}->fetchall_hashref('@{[ $self->key_field() ]}');");
				$self->catalogue()->code_segments()->verbose_msg()->new(
					target_name => $self->properties()->script_name(),
					user_prog => $c,
					msg_text => "Table @{[ $self->name() ]} loaded \@{[ scalar(keys(\%\$@{[ $self->tname() ]})) ]} records."
				)->prepare() if ($self->configuration()->verbose()); 
				$self->input_dataset()->code_close($c);
				$c->code("return \$@{[$self->tname() ]};");
			$c->close_block();
		$c->close_block();
		return $c;
	}
	sub translate
	{
		my $self = shift;
		my $key_exp = shift; 
		my $field = shift; # || undef;
		my $show_synonyms = shift;
		my $target_obj = shift; #TODO: not best solution?
		my $c = ETL::Pequel3::CodeStyler::Program::Perl->new();
		if (defined($field) && !ref($field)) {
			$field =~ s/^.*\-\>//;
			my $f = $self->fields()->exists($field); 
			$self->err()->user_error(10307, "Unknown field '$field' for table '@{[ $self->name() ]}'")
				unless (defined($f) && ref($f));
			$field = $f;
		}
		if (defined($field)) {
			$c->code($field->getvar($key_exp));
			$target_obj->xref()->references($field) if ($target_obj->can('xref'));
			$field->xref()->referenced_by($target_obj) if ($field->can('xref'));
		} else {
			# keyfld can be an expression eg: another macro
			my $key_eval = $key_exp =~ /[&\(|\[|,]/ ? "\@{[ $key_exp ]}" : $key_exp;
			$c->code('$' . $self->tname() . '->{qq{' . $key_eval . '}}');
		}
		return $c;
	}
}
# ----------------------------------------------------------------------------------------------------
{	
	package ETL::Pequel3::Type::Table::Pequel::Abstract;
	use base qw(ETL::Pequel3::Type::Table::External::Abstract);
	use Class::STL::ClassMembers
		Class::STL::ClassMembers::DataMember->new(name => 'description', default => "The data for this table type is loaded from an external F<pequel> I<dataset>. This table type can be loaded I<dynamically> or I<statically>. Please refer to the description for F<external> for further information regarding F<static> and F<dynamic>."),
		Class::STL::ClassMembers::DataMember->new(name => 'name', default => 'pequel');
	use Class::STL::ClassMembers::Constructor;
	sub factory
	{
		my $self = shift;
		my %p = @_; # table_type, static, dataset_spec, ...
		return 
		(
			defined($p{input_dataset}) 
			&& 
			(
				$p{table_type} eq $self->name()
				|| 
				(
#?					$p{table_type} eq 'pequel'
					$p{input_dataset}->datasource()->datasource_name() eq 'pequel'
					&& 
					( 
						($self->isa('ETL::Pequel3::Type::Table::ExternalStatic') && $p{static})
						|| 
						(!$self->isa('ETL::Pequel3::Type::Table::ExternalStatic') && !$p{static})
					)
				)
			)
		) 
		? $self->new(%p) : 0;
	}
	sub prepare
	{
		my $self = shift;
		my $items = shift; # local table data items

		$self->err()->user_error(10213, "Key field not defined for table '@{[ $self->name() ]}'")
			unless (defined($self->key_field()));

		$self->input_dataset()->map_output(main => $self->pequel_ref(), field_map => $self->field_map());

		$self->input_dataset()->datasource()->pequel_ref()->output()->output_dataset()->datasource()->sorter(
			$self->input_dataset()->datasource()->sorter());

		$self->err()->user_error(10214, "Key field '@{[ 
				$self->key_field() ]}' does not exist in pequel '@{[ 
				$self->input_dataset()->datasource()->pequel_ref()->pequel_name() 
			]}'")
			unless (grep($self->key_field() eq $_->name(), 
					$self->input_dataset()->datasource()->pequel_ref()->output_interface()));

		$self->key_type($self->input_dataset()->datasource()->pequel_ref()->output()->output_fields()->exists($self->key_field())->pequel_type()->name())
			unless (defined($self->key_type()));
		my $key_type = $self->key_type();
		$key_type = $self->pequel_types()->exists($key_type)
			|| $self->err()->user_error(10210, "Unkown pequel-type '@{[ $key_type ]}' for table '@{[ $self->name() ]}' key_field");
		$self->attach_sorter($key_type);
	}
}
# ----------------------------------------------------------------------------------------------------
{	
	package ETL::Pequel3::Type::Table::PequelStatic;
	use base qw(ETL::Pequel3::Type::Table::Pequel::Abstract);
	use base qw(ETL::Pequel3::Type::Table::ExternalStatic);
	use Class::STL::ClassMembers
		Class::STL::ClassMembers::DataMember->new(name => 'description', default => "The data for this table type is loaded from an external F<pequel> I<dataset>. With static tables the data is pre-loaded during the code-generation resulting with the table-data embedded within the generated program (as a I<hash> variable)."),
		Class::STL::ClassMembers::DataMember->new(name => 'name', default => 'pequel_static');
	use Class::STL::ClassMembers::Constructor;
	sub code_load_table
	{
		my $self = shift;
		return $self->ETL::Pequel3::Type::Table::ExternalStatic::code_load_table(@_);
	}
}
# ----------------------------------------------------------------------------------------------------
{	
	package ETL::Pequel3::Type::Table::PequelDynamic;
	use base qw(ETL::Pequel3::Type::Table::Pequel::Abstract);
	use base qw(ETL::Pequel3::Type::Table::ExternalDynamic);
	use Class::STL::ClassMembers
		Class::STL::ClassMembers::DataMember->new(name => 'description', default => "The data for this table type is loaded from an external F<pequel> I<dataset>. The data for a dynamic type table is loaded at run-time, that is, when the I<generated> program executes."),
		Class::STL::ClassMembers::DataMember->new(name => 'name', default => 'pequel_dynamic');
	use Class::STL::ClassMembers::Constructor;
	sub code_load_table
	{
		my $self = shift;
		return $self->ETL::Pequel3::Type::Table::ExternalDynamic::code_load_table(@_);
	}
}
# ----------------------------------------------------------------------------------------------------
# CATALOGUE
# ----------------------------------------------------------------------------------------------------
{
#?	package ETL::Pequel3::Catalogue::Tables::Abstract;
	package ETL::Pequel3::Type::Table::Catalogue::Abstract;
	use base qw(ETL::Pequel3::Type::Catalogue);
	use Class::STL::ClassMembers
		Class::STL::ClassMembers::DataMember->new(name => 'target_mem_name', default => 'name'),
		Class::STL::ClassMembers::DataMember->new(name => 'element_type', default => 'ETL::Pequel3::Type::Table::Abstract');
	use Class::STL::ClassMembers::Constructor;
}
# ----------------------------------------------------------------------------------------------------
{
#?	package ETL::Pequel3::Catalogue::Tables;
	package ETL::Pequel3::Type::Table::Catalogue;
	use base qw(ETL::Pequel3::Type::Table::Catalogue::Abstract);
	use Class::STL::ClassMembers
		Class::STL::ClassMembers::DataMember->new(name => 'catalogue_name', default => 'table_types');
	use Class::STL::ClassMembers::SingletonConstructor;
	sub new_extra
	{
		my $self = shift;
		$self->push_back(
			ETL::Pequel3::Type::Table::Local->_new(),
			ETL::Pequel3::Type::Table::PequelStatic->_new(),
			ETL::Pequel3::Type::Table::PequelDynamic->_new(),
			ETL::Pequel3::Type::Table::Pequel::Abstract->_new(),
			ETL::Pequel3::Type::Table::DbiStatic->_new(),
			ETL::Pequel3::Type::Table::DbiDynamic->_new(),
			ETL::Pequel3::Type::Table::Dbi::Abstract->_new(),
			ETL::Pequel3::Type::Table::ExternalStatic->_new(),
			ETL::Pequel3::Type::Table::ExternalDynamic->_new(),
			ETL::Pequel3::Type::Table::External::Abstract->_new(),
		);
		return $self;
	}
}
# ----------------------------------------------------------------------------------------------------
# FACTORY
# ----------------------------------------------------------------------------------------------------
{
#?	package ETL::Pequel3::Factory::Tables::Abstract;
	package ETL::Pequel3::Type::Table::Factory::Abstract;
	use ETL::Pequel3::Type::Factory;
	use base qw(ETL::Pequel3::Type::Factory::Abstract);
	use Class::STL::ClassMembers 
		Class::STL::ClassMembers::DataMember->new(name => 'factory_name', default => 'tables'),
		Class::STL::ClassMembers::DataMember->new(name => 'target_mem_name', default => 'name'),
		Class::STL::ClassMembers::DataMember->new(name => 'element_type', default => 'ETL::Pequel3::Type::Table::Abstract'),
		Class::STL::ClassMembers::DataMember->new(name => 'catalogue_type', default => 'table_types');
	use Class::STL::ClassMembers::Constructor;
	sub factory
	{
		my $self = shift;
		my %p = @_; # table_type, static, dataset_spec, ...
		$self->err()->user_error(10209, "Undefined pequel_ref parameter!") 
		unless (defined($p{pequel_ref}));
		$self->err()->user_error(10210, "Undefined table_type parameter!") 
		unless (defined($p{table_type}));

		$p{input_dataset} = ETL::Pequel3::Type::DataSet::Input::Factory::Global->new()->factory(
			dataset_spec => $p{dataset_spec},
			pequel_ref => $p{pequel_ref}
		) 
			if (defined($p{dataset_spec}));

		foreach ($self->catalogue()->to_array()) {
			if ((my $tobj = $_->factory(%p, pequel_ref => $p{pequel_ref})) != 0) {
				if (defined($p{input_dataset})) {
					$p{input_dataset}->datasource()->fdname($tobj->tname());
					$p{input_dataset}->input_fields($tobj->fields());
#?					$tobj->fields()->dataset($p{input_dataset});
				}
				$self->err()->trace_msg(10, "@{[ $tobj->pequel_ref()->pequel_name() ]} -->"
					. "Table:@{[ $tobj->name() ]} [@{[ ref($self) ]}]");
				return $tobj;
			}
		}
		$self->err()->user_error(10208, "No match for table type @{[ 
				$p{table_type} 
				. ($p{static} ? q/(static)/ : q/(dynamic)/) 
				. q/ [dataset_spec => /
				. (defined($p{input_dataset}) ? $p{dataset_spec} : q/NULL/)
				. q/]/
			]} for table @{[ $p{name} ]}!");
		return 0;
	}	
}
# ----------------------------------------------------------------------------------------------------
{
	package ETL::Pequel3::Type::Table::Factory::Local;
	use base qw(ETL::Pequel3::Type::Table::Factory::Abstract);
	use Class::STL::ClassMembers;
	use Class::STL::ClassMembers::Constructor;
}
# ----------------------------------------------------------------------------------------------------
{
	package ETL::Pequel3::Type::Table::Factory::Global;
	use base qw(ETL::Pequel3::Type::Table::Factory::Abstract);
	use Class::STL::ClassMembers;
	use Class::STL::ClassMembers::SingletonConstructor;
}
# ----------------------------------------------------------------------------------------------------
1;