DESCRIPTION

This is the base class for using table records as plain Perl objects. The subclassses are:$/$/=over BASE_CLASS

  foreach my $t (@$tables) {
    my $package =
      $namespace . '::' . (join '', map { ucfirst lc } split /_/, $t->{TABLE_NAME});
    my $COLUMNS = Data::Dumper->Dump([$t->{COLUMNS}],    ['$COLUMNS']);
    my $ALIASES = Data::Dumper->Dump([$t->{ALIASES}],    ['$ALIASES']);
    my $CHECKS  = Data::Dumper->Dump([$t->{CHECKS}],     ['$CHECKS']);
    my $TABLE   = Data::Dumper->Dump([$t->{TABLE_NAME}], ['$TABLE_NAME']);
    my $name_description = "A class for $t->{TABLE_TYPE} $t->{TABLE_NAME} in schema $t->{TABLE_SCHEM}";
    $schemas->{$namespace}{code}[0] .=qq|$/=item L<$package> - $name_description$/|;
    push @{$schemas->{$namespace}{code}}, qq|package $package; #A table/row class
use 5.10.1;
use strict;
use warnings;
use utf8;
use parent qw($namespace);
| . qq|
sub is_base_class{return 0}
my $TABLE
sub TABLE {return \$TABLE_NAME}| . qq|
sub PRIMARY_KEY{return '$t->{PRIMARY_KEY}'}
my $COLUMNS
sub COLUMNS {return \$COLUMNS}
my $ALIASES
sub ALIASES {return \$ALIASES}
my $CHECKS
sub CHECKS {return \$CHECKS}

__PACKAGE__->QUOTE_IDENTIFIERS($t->{QUOTE_IDENTIFIERS}); #__PACKAGE__->BUILD;#build accessors during load

1; | . qq|$/__END__$/$/=pod$/$/=encoding utf8$/$/=head1 NAME

$name_description

| . qq|=head1 SYNOPSIS$/$/=head1 DESCRIPTION$/$/=head1 COLUMNS$/ Each column from table $t-{TABLE_NAME}> has an accessor method in this class. | . (join '', map { $/ . '=head2 ' . $_ . $/ } @{$t->{COLUMNS}}) . qq|$/=head1 ALIASES$/$/=head1 GENERATOR$/$/$class$/$/=head1 SEE ALSO $/$/| . qq|$namespace, DBIx::Simple::Class, $class|; } # end foreach my $t (@$tables)

  $schemas->{$namespace}{code}[0] .=qq|$/=back$/$/=head1 GENERATOR$/$/L<$class>
$/$/=head1 SEE ALSO$/$/
L<$class>, L<DBIx::Simple::Class>, L<DBIx::Simple>, L<Mojolicious::Plugin::DSC>
$/=head1 LICENSE AND COPYRIGHT$/$/$ENV{USER}...$/$/=cut
|;
  if (defined wantarray) {
    if (wantarray) {
      return @{$schemas->{$namespace}{code}};
    }
    else {
      return join '', @{$schemas->{$namespace}{code}};
    }
  }
  return;
}

sub load_schema { my ($class, $args) = _get_obj_args(@_); unless ($args->{namespace}) { $args->{namespace} = $class->dbh->{Name}; if ($args->{namespace} =~ /(database|dbname|db)=([^;]+);?/x) { $args->{namespace} = $2; } $args->{namespace} =~ s/\W//xg; $args->{namespace} = 'DSCS::' . (join '', map { ucfirst lc } split /_/, $args->{namespace}); }

  my $tables = $class->_get_table_info($args);

  #get table columns, PRIMARY_KEY, foreign keys
  $class->_get_column_info($tables);

  #generate COLUMNS, ALIASES, CHECKS
  $class->_generate_COLUMNS_ALIASES_CHECKS($tables);

  #generate code
  if (defined wantarray) {
    return $class->_generate_CODE($args);
  }
  else {
    $class->_generate_CODE($args);
  }
  return;
}

sub dump_schema_at { my ($class, $args) = _get_obj_args(@_); $args->{lib_root} ||= $INC[0]; my ($namespace, @namespace, @base_path, $schema_path);

  #_generate_CODE() should be called by now
  #we always have only one key
  $namespace = (keys %$schemas)[0]
    || Carp::croak('Please first call ' . __PACKAGE__ . '->load_schema()!');

  require File::Path;
  require File::Spec;
  require IO::File;
  @namespace = split /::/, $namespace;
  @base_path = File::Spec->splitdir($args->{lib_root});

  $schema_path = File::Spec->catdir(@base_path, @namespace);

  if (eval "require $namespace") {
    carp( "Module $namespace is already installed at "
        . $INC{join('/', @namespace) . '.pm'}
        . ". Please avoid namespace collisions...");
  }
  say('Will dump schema at ' . $args->{lib_root});

  #We should be able to continue safely now...
  my $tables = $schemas->{$namespace}{tables};
  my $code   = $schemas->{$namespace}{code};
  if (!-d $schema_path) {
    eval { File::Path::make_path($schema_path); }
      || carp("Can not make path $schema_path.$/$!. Quitting...") && return;
  }

  if ((!$args->{overwrite} && !-f "$schema_path.pm") || $args->{overwrite}) {
    carp("Overwriting $schema_path.pm...") if $args->{overwrite} && $class->DEBUG;
    my $base_fh = IO::File->new("> $schema_path.pm")
      || croak("Could not open $schema_path.pm for writing" . $!);
    print $base_fh $code->[0];
    $base_fh->close;
  }

  foreach my $i (0 .. @$tables - 1) {
    my $filename =
      (join '', map { ucfirst lc } split /_/, $tables->[$i]{TABLE_NAME}) . '.pm';
    next if (-f "$schema_path/$filename" && !$args->{overwrite});
    carp("Overwriting $schema_path/$filename...")
      if $args->{overwrite} && $class->DEBUG;
    my $fh = IO::File->new("> $schema_path/$filename");
    if (defined $fh) {
      print $fh $code->[$i + 1];
      $fh->close;
    }
    else {
      carp("$schema_path/$filename: $!. Quitting!");
      return;
    }
  }
  return 1;
}

NAME

DBIx::Simple::Class::Schema - Create and use classes representing tables from a database

SYNOPSIS

  #Somewhere in a utility script or startup() fo your application.
  DBIx::Simple::Class::Schema->dbix(DBIx::Simple->connect(...));
  my $perl_code = DBIx::Simple::Class::Schema->load_schema(
    namespace =>'My::Model',
    table => '%',              #all tables from the current database
    type  => "'TABLE','VIEW'", # make classes for tables and views
  );

  #Now eval() to use your classes.
  eval $perl_code || croak($@);


  #Or load and save it for more customisations and later usage.
  DBIx::Simple::Class::Schema->load_schema(
    namespace =>'My::Model',
    table => '%',              #all tables from the current database
    type  => "'TABLE','VIEW'", # make classes for tables and views
  );
  DBIx::Simple::Class::Schema->dump_schema_at(
    lib_root => "$ENV{PERL_LOCAL_LIB_ROOT}/lib"
    overwrite =>1 #overwrite existing files
  ) || Carp::croak 'Something went wrong! See above...';

DESCRIPTION

DBIx::Simple::Class::Schema automates the creation of classes from database tables. You can use it when you want to prototype quickly your application. It is also very convenient as an initial generator and dumper of your classes representing your database tables.

METHODS

load_schema

Class method.

  Params:
    namespace - String. The class name for your base class,
      default: 'DSCS::'.(join '', map { ucfirst lc } split /_/, $database)
    table - SQL string for a LIKE clause,
      default: '%'
    type - SQL String for an IN clause.
      default: "'TABLE','VIEW'"

Extracts tables' information from the current connection and generates Perl classes representing those tabels or views. If called in list context returns an array with perl code for each package. The first package is the base class. If called in scalar context returns all the generated code as a string. In void context returns undefined. The generated classes are saved internally and are available for use by "dump_schema_at". This makes it very convenient for quickly prototyping applications by just modifying tables in your database.

  my $perl_code = DBIx::Simple::Class::Schema->load_schema();
  #concatenaded code as one string
  eval $perl_code || croak($@);
  #...
  my $user = Dbname::User->find(2345);
  
  #or My::Schema, My::Schema::Table1, My::Schema::Table2,...
  my @perl_code = DBIx::Simple::Class::Schema->load_schema();
  
  #or just prepare code before dumping it to disk.
  DBIx::Simple::Class::Schema->load_schema();

dump_schema_at

Class method.

  Params:
    lib_root: String - Where classes will be dumped.
      default: $INC[0]
    overwrite: boolean -1/0 Should it overwrite existing classes with the same name?
      default: 0

Uses the generated code by "load_schema" and saves each class on the disk. Does several checks:

Checks if a file with the name of your base class exists and exits if the flag overwrite is not set.
Checks if there is a module with the same name as your base class installed and exits if there is such module. This is done to avoid namespace collisions.
Checks if the files can be written to disk and exit immediately if there is a problem.

For every check above issues the system warning so you, the developer, can decide what to do. Returns true on success.

SUPPORTED DATABASE DRIVERS

DBIx::Simple::Class::Schema strives to be DBD agnostic and uses only functionality specified by DBI. This means that if a driver implements the methods specifyed in DBI it is supported. However currently only tests for DBD::SQLite and DBD::mysql are written. Feel free to contribute with tests for your prefered driver. The following methods are used to retreive information form the database:

SUPPORTED SQL TYPES

Currently some minimal "CHECKS" in DBIx::Simple::Class are automatically generated for TYPE_NAMEs matching /INT/i,/FLOAT|DOUBLE|DECIMAL/i, /CHAR|TEXT|CLOB/i. You are supposed to write your own business-specific checks.

LICENSE AND COPYRIGHT

This program is free software, you can redistribute it and/or modify it under the terms of the Artistic License version 2.0.

See http://www.opensource.org/licenses/artistic-license-2.0 for more information.

To install DBIx::Simple::Class, copy and paste the appropriate command in to your terminal.

cpanm

cpanm DBIx::Simple::Class

CPAN shell

perl -MCPAN -e shell
install DBIx::Simple::Class

For more information on module installation, please visit the detailed CPAN module installation guide.

	Global
`s`	Focus search bar
`?`	Bring up this help dialog

	GitHub
`g` `p`	Go to pull requests
`g` `i`	go to github issues (only if github is preferred repository)

	POD
`g` `a`	Go to author
`g` `c`	Go to changes
`g` `i`	Go to issues
`g` `d`	Go to dist
`g` `r`	Go to repository/SCM
`g` `s`	Go to source
`g` `b`	Go to file browse

	Search terms
module: (e.g. module:Plugin)
distribution: (e.g. distribution:Dancer auth)
author: (e.g. author:SONGMU Redis)
version: (e.g. version:1.00)

DESCRIPTION

NAME

SYNOPSIS

DESCRIPTION

METHODS

load_schema

dump_schema_at

SUPPORTED DATABASE DRIVERS

SUPPORTED SQL TYPES

SEE ALSO

LICENSE AND COPYRIGHT

Module Install Instructions