Changeset 51eb11155a755071e75ebabf515931861e5bd0f7 in xas-model


Ignore:
Timestamp:
12/02/14 16:08:35 (5 years ago)
Author:
Kevin L. Esteb <kevin@…>
Branches:
master
Children:
9c6940e2899e7c8beb9361e98bb6daa0d0884fed
Parents:
5250ce3bd7dfd5e59c99936400210013b992b151
git-author:
Kevin L. Esteb <kevin@…> (12/02/14 16:08:35)
git-committer:
Kevin L. Esteb <kevin@…> (12/02/14 16:08:35)
Message:

Working on a problem with generating sql code for a schema

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/bin/xas-create-schema

    r80c06eaf6472f3f863e9c244e56b16f647851947 r51eb11155a755071e75ebabf515931861e5bd0f7  
    4040use lib "../lib"; 
    4141use XAS::Apps::Database::Schema; 
     42 
     43$SQL::Translator::DEBUG = 1; 
    4244 
    4345main: { 
  • trunk/lib/XAS/Apps/Database/Schema.pm

    r80c06eaf6472f3f863e9c244e56b16f647851947 r51eb11155a755071e75ebabf515931861e5bd0f7  
    11package XAS::Apps::Database::Schema; 
    22 
    3 use XAS::Model::Database; 
     3use XAS::Model::Database 
     4  schema => 'XAS::Model::Database', 
     5  tables => ':all' 
     6; 
    47 
    58use XAS::Class 
     
    710  version   => '0.02', 
    811  base      => 'XAS::Lib::App', 
    9   accessors => 'dbtype revision directory schema', 
     12  accessors => 'dbtype revision directory database db', 
    1013; 
    1114 
     
    1720    my $self = shift; 
    1821 
    19     $self->{schema} = XAS::Model::Database->opendb('database'); 
     22    my $database = $self->database; 
     23 
     24    $self->{db} = XAS::Model::Database->opendb($database); 
    2025 
    2126} 
     
    2833    $self->log->info('starting up'); 
    2934 
    30     $self->schema->create_ddl_dir( 
     35    $self->db->create_ddl_dir( 
    3136        [$self->dbtype], 
    3237        $self->revision, 
     
    4449    $self->{revision}  = '0.01'; 
    4550    $self->{directory} = './sql/'; 
     51    $self->{database}  = 'database'; 
    4652 
    4753    return { 
     
    4955        'revision=s'  => \$self->{revision}, 
    5056        'directory=s' => \$self->{directory}, 
     57        'database=s'  => \$self->{database}, 
    5158    }; 
    5259 
  • trunk/lib/XAS/Model/Database.pm

    rfc5d23c129b6246a6eb88d5f78fdde934718e237 r51eb11155a755071e75ebabf515931861e5bd0f7  
    1111  base       => 'DBIx::Class::Schema::Config XAS::Base', 
    1212  import     => 'class CLASS', 
    13   constants  => 'DELIMITER PKG REFS ONCE', 
     13  constants  => 'DELIMITER PKG REFS ONCE HASH ARRAY', 
    1414  filesystem => 'File', 
    1515  exports => { 
    1616    hooks => { 
    17       schema => \&schema, 
    18       table  => \&tables, 
    19       tables => \&tables, 
     17      schema => [ \&schema, 1 ], 
     18      table  => [ \&tables, 1 ], 
     19      tables => [ \&tables, 1 ], 
    2020    } 
    2121  }, 
    22   vars => { 
    23     TABLES => {} 
    24   } 
    2522; 
    2623 
     
    9895 
    9996sub tables { 
    100     my ($class, $target, $symbol, $values) = @_; 
    101  
    102     my $value  = shift(@$values); 
    103     my @tables = split(DELIMITER, $value); 
    104  
    105     foreach my $table (@tables) { 
     97    my $self   = shift; 
     98    my $target = shift; 
     99    my $symbol = shift; 
     100    my $tables = @_ == 1 ? shift : [ @_ ]; 
     101 
     102        my $TABLES = $self->class->var('TABLES'); 
     103 
     104    $tables = [ split(DELIMITER, $tables) ] unless (ref($tables) eq ARRAY); 
     105 
     106    foreach my $table (@$tables) { 
    106107 
    107108        if ($table ne ':all') { 
    108109 
    109             if (defined($TABLES->{$table})) { 
    110  
    111                 no strict REFS; 
    112                 no warnings ONCE; 
    113  
    114                 *{$target.PKG.$table} = sub {$TABLES->{$table}}; 
    115  
    116             } else { 
    117  
    118                 $class->throw("$table is not exported by $class"); 
     110            $self->class->constant($table => $TABLES->{$table}); 
     111 
     112        } else { 
     113 
     114            while (my ($key, $value) = each(%{$TABLES->{tables}})) { 
     115 
     116                $self->class->constant($key => $value); 
    119117 
    120118            } 
    121119 
    122         } else { 
    123  
    124             while (my ($key, $value) = each(%$TABLES)) { 
    125  
    126                 no strict REFS; 
    127                 no warnings ONCE; 
    128  
    129                 *{$target.PKG.$key} = sub {$value}; 
     120            last; 
     121 
     122        } 
     123 
     124    } 
     125 
     126    return $self; 
     127 
     128} 
     129 
     130sub schema { 
     131    my $self    = shift; 
     132    my $target  = shift; 
     133    my $symbol  = shift; 
     134    my $schemas = @_ == 1 ? shift : [ @_ ]; 
     135 
     136    $schemas = [ split(DELIMITER, $schemas) ] unless (ref($schemas) eq ARRAY); 
     137 
     138    foreach my $schema (@$schemas) { 
     139 
     140        my $pattern = $schema . '::'; 
     141 
     142        # loading our schema 
     143 
     144        CLASS->load_namespaces(result_namespace => "+$schema"); 
     145 
     146        # building our TABLES hash 
     147 
     148        my $modules = Class::Inspector->subclasses('UNIVERSAL'); 
     149 
     150        foreach my $module (@$modules) { 
     151 
     152            if ($module =~ m/$pattern/) { 
     153 
     154                my @parts = split('::', $module); 
     155                my $begin = scalar(@parts) - 1; 
     156                my $name = join('', splice(@parts, $begin, $#parts)); 
     157 
     158                $self->class->hash_value('TABLES', $name, $module); 
    130159 
    131160            } 
    132161 
    133             last; 
    134  
    135162        } 
    136163 
    137164    } 
    138165 
    139 } 
    140  
    141 sub schema { 
    142     my ($class, $target, $symbol, $values) = @_; 
    143  
    144     my $name; 
    145     my $begin; 
    146     my @parts; 
    147     my $modules; 
    148     my $namespace = shift(@$values); 
    149     my $pattern = $namespace . '::'; 
    150  
    151     # loading our schema 
    152  
    153     CLASS->load_namespaces(result_namespace => "+$namespace"); 
    154  
    155     # building our TABLES hash 
    156  
    157     $modules = Class::Inspector->subclasses('UNIVERSAL'); 
    158  
    159     foreach my $module (@$modules) { 
    160  
    161         if ($module =~ m/$pattern/) { 
    162  
    163             @parts = split('::', $module); 
    164             $begin = scalar(@parts) - 1; 
    165             $name = join('', splice(@parts, $begin, $#parts)); 
    166  
    167             $TABLES->{$name} = $module; 
    168  
    169         } 
    170  
    171     } 
     166    return $self; 
    172167 
    173168} 
Note: See TracChangeset for help on using the changeset viewer.