Added 'date' to "string" types.
[dbsrgits/SQL-Translator.git] / lib / SQL / Translator / Producer / SQLite.pm
index 774892f..070fe1a 100644 (file)
@@ -1,11 +1,9 @@
 package SQL::Translator::Producer::SQLite;
 
 # -------------------------------------------------------------------
-# $Id: SQLite.pm,v 1.2 2003-03-12 14:17:11 dlc Exp $
+# $Id: SQLite.pm,v 1.11 2004-03-16 13:29:11 kycl4rk Exp $
 # -------------------------------------------------------------------
-# Copyright (C) 2003 Ken Y. Clark <kclark@cpan.org>,
-#                    darren chamberlain <darren@cpan.org>,
-#                    Chris Mungall <cjm@fruitfly.org>
+# Copyright (C) 2002-4 SQLFairy Authors
 #
 # This program is free software; you can redistribute it and/or
 # modify it under the terms of the GNU General Public License as
@@ -22,149 +20,189 @@ package SQL::Translator::Producer::SQLite;
 # 02111-1307  USA
 # -------------------------------------------------------------------
 
+=head1 NAME
+
+SQL::Translator::Producer::SQLite - SQLite producer for SQL::Translator
+
+=head1 SYNOPSIS
+
+  use SQL::Translator;
+
+  my $t = SQL::Translator->new( parser => '...', producer => 'SQLite' );
+  $t->translate;
+
+=head1 DESCRIPTION
+
+This module will produce text output of the schema suitable for SQLite.
+
+=cut
+
 use strict;
 use Data::Dumper;
-use SQL::Translator::Utils qw(debug);
+use SQL::Translator::Schema::Constants;
+use SQL::Translator::Utils qw(debug header_comment);
 
 use vars qw[ $VERSION $DEBUG $WARN ];
-$VERSION = sprintf "%d.%02d", q$Revision: 1.2 $ =~ /(\d+)\.(\d+)/;
+
+$VERSION = sprintf "%d.%02d", q$Revision: 1.11 $ =~ /(\d+)\.(\d+)/;
+$DEBUG = 0 unless defined $DEBUG;
+$WARN = 0 unless defined $WARN;
 
 my %used_identifiers = ();
 my $max_id_length    = 30;
 my %global_names;
 my %truncated;
 
-sub import {
-    warn "loading " . __PACKAGE__ . "...\n";
-}
-
 sub produce {
-    my ($translator, $data) = @_;
-    $DEBUG                  = $translator->debug;
-    $WARN                   = $translator->show_warnings;
-    my $no_comments         = $translator->no_comments;
-    my $add_drop_table      = $translator->add_drop_table;
+    my $translator     = shift;
+    local $DEBUG       = $translator->debug;
+    local $WARN        = $translator->show_warnings;
+    my $no_comments    = $translator->no_comments;
+    my $add_drop_table = $translator->add_drop_table;
+    my $schema         = $translator->schema;
 
     debug("PKG: Beginning production\n");
 
-    my $create; 
-    unless ( $no_comments ) {
-        $create .= sprintf "--\n-- Created by %s\n-- Created on %s\n--\n\n",
-            __PACKAGE__, scalar localtime;
-    }
+    my $create = '';
+    $create .= header_comment unless ($no_comments);
+    $create .= "BEGIN TRANSACTION;\n\n";
+
+    my ( @index_defs, @constraint_defs, @trigger_defs );
+    for my $table ( $schema->get_tables ) {
+        my $table_name = $table->name;
+        debug("PKG: Looking at table '$table_name'\n");
+
+        my @fields = $table->get_fields or die "No fields in $table_name";
 
-    for my $table ( keys %{ $data } ) {
-        debug("PKG: Looking at table '$table'\n");
-        my $table_data = $data->{$table};
-        my @fields = sort { 
-            $table_data->{'fields'}->{$a}->{'order'} 
-            <=>
-            $table_data->{'fields'}->{$b}->{'order'}
-        } keys %{$table_data->{'fields'}};
+        #
+        # Header.
+        #
+        $create .= "--\n-- Table: $table_name\n--\n" unless $no_comments;
+        $create .= qq[DROP TABLE $table_name;\n] if $add_drop_table;
+        $create .= "CREATE TABLE $table_name (\n";
 
         #
-        # Header.  Should this look like what mysqldump produces?
+        # How many fields in PK?
         #
-        $create .= "--\n-- Table: $table\n--\n" unless $no_comments;
-        $create .= qq[DROP TABLE $table;\n] if $add_drop_table;
-        $create .= "CREATE TABLE $table (";
+        my $pk        = $table->primary_key;
+        my @pk_fields = $pk ? $pk->fields : ();
 
         #
         # Fields
         #
-        for (my $i = 0; $i <= $#fields; $i++) {
-            my $field = $fields[$i];
-            debug("PKG: Looking at field '$field'\n");
-            my $field_data = $table_data->{'fields'}->{$field};
-            my @fdata = ("", $field);
-            $create .= "\n";
+        my ( @field_defs, $pk_set );
+        for my $field ( @fields ) {
+            my $field_name = $field->name;
+            debug("PKG: Looking at field '$field_name'\n");
+            my $field_def = $field_name;
 
             # data type and size
-            my $data_type = lc $field_data->{'data_type'};
-            my $list      = $field_data->{'list'} || [];
-            my $commalist = join ",", @$list;
-            my $size;
-
-            if ( $data_type eq 'set' ) {
-                $data_type = 'varchar';
-                $size      = length $commalist;
-            }
-            else {
-                $size = join( ', ', @{ $field_data->{'size'} || [] } );
+            my $size      = $field->size;
+            my $data_type = $field->data_type;
+            $data_type    = 'varchar' if lc $data_type eq 'set';
+
+            if ( $data_type =~ /timestamp/i ) {
+                push @trigger_defs, 
+                    "CREATE TRIGGER ts_${table_name} ".
+                    "after insert on $table_name\n".
+                    "begin\n".
+                    "  update $table_name set $field_name=timestamp() ".
+                       "where id=new.id;\n".
+                    "end;\n"
+                ;
+
             }
 
-            push @fdata, sprintf "%s%s", $data_type, ($size) ? "($size)" : '';
+            #
+            # SQLite is generally typeless, but newer versions will
+            # make a field autoincrement if it is declared as (and
+            # *only* as) INTEGER PRIMARY KEY
+            #
+            if ( 
+                $field->is_primary_key && 
+                scalar @pk_fields == 1 &&
+                (
+                    $data_type =~ /int(eger)?$/i
+                    ||
+                    ( $data_type =~ /^number?$/i && $size !~ /,/ )
+                )
+            ) {
+                $data_type = 'INTEGER PRIMARY KEY';
+                $size      = undef;
+                $pk_set    = 1;
+            }
 
-            # MySQL qualifiers
-#            for my $qual ( qw[ binary unsigned zerofill ] ) {
-#                push @fdata, $qual 
-#                    if $field_data->{ $qual } ||
-#                       $field_data->{ uc $qual };
-#            }
+            $field_def .= sprintf " %s%s", $data_type, 
+                ( !$field->is_auto_increment && $size ) ? "($size)" : '';
 
             # Null?
-            push @fdata, "NOT NULL" unless $field_data->{'null'};
+            $field_def .= ' NOT NULL' unless $field->is_nullable;
 
             # Default?  XXX Need better quoting!
-            my $default = $field_data->{'default'};
+            my $default = $field->default_value;
             if ( defined $default ) {
                 if ( uc $default eq 'NULL') {
-                    push @fdata, "DEFAULT NULL";
+                    $field_def .= ' DEFAULT NULL';
                 } else {
-                    push @fdata, "DEFAULT '$default'";
+                    $field_def .= " DEFAULT '$default'";
                 }
             }
 
-            # auto_increment?
-#            push @fdata, "auto_increment" if $field_data->{'is_auto_inc'};
-
-            # primary key?
-            # This is taken care of in the indices, could be duplicated here
-            # push @fdata, "PRIMARY KEY" if $field_data->{'is_primary_key'};
-
+            push @field_defs, $field_def;
+        }
 
-            $create .= (join " ", '', @fdata);
-            $create .= "," unless ($i == $#fields);
+        if ( 
+            scalar @pk_fields > 1 
+            || 
+            ( @pk_fields && !$pk_set ) 
+        ) {
+            push @field_defs, 'PRIMARY KEY (' . join(', ', @pk_fields ) . ')';
         }
+
         #
         # Indices
         #
-        my @index_creates;
-        my $idx_name_default;
-        for my $index ( @{ $table_data->{'indices'} || [] } ) {
-            my ($name, $type, $fields) = @{ $index }{ qw[ name type fields ] };
-            $name ||= '';
-            my $index_type = 
-                $type eq 'primary_key' ? 'PRIMARY KEY' :
-                $type eq 'unique'      ? 'UNIQUE INDEX'  : 'INDEX';
-            if ( $type eq 'primary_key' ) {
-                $create .= join(",\n", '', 
-                    "  $index_type $name (" . join( ', ', @$fields ) . ')'
-                );
-            }
-            else {
-                $name = mk_name( 
-                    $table, $name || ++$idx_name_default
-                );
-                push @index_creates, 
-                    "CREATE $index_type $name on $table ".
-                    '(' . join( ', ', @$fields ) . ')';
-            }
+        my $idx_name_default = 'A';
+        for my $index ( $table->get_indices ) {
+            my $name   = $index->name;
+            $name      = mk_name($table_name, $name || ++$idx_name_default);
+
+            # strip any field size qualifiers as SQLite doesn't like these
+            my @fields = map { s/\(\d+\)$//; $_ } $index->fields;
+            push @index_defs, 
+                "CREATE INDEX $name on $table_name ".
+                '(' . join( ', ', @fields ) . ');';
         }
 
-        $create .= "\n);\n";
-
-        for my $index_create ( @index_creates ) {
-            $create .= "$index_create;\n";
+        #
+        # Constraints
+        #
+        my $c_name_default = 'A';
+        for my $c ( $table->get_constraints ) {
+            next unless $c->type eq UNIQUE; 
+            my $name   = $c->name;
+            $name      = mk_name($table_name, $name || ++$idx_name_default);
+            my @fields = $c->fields;
+
+            push @constraint_defs, 
+                "CREATE UNIQUE INDEX $name on $table_name ".
+                '(' . join( ', ', @fields ) . ');';
         }
 
+        $create .= join(",\n", map { "  $_" } @field_defs ) . "\n);\n";
+
         $create .= "\n";
     }
 
+    for my $def ( @index_defs, @constraint_defs, @trigger_defs ) {
+        $create .= "$def\n";
+    }
+
+    $create .= "COMMIT;\n";
+
     return $create;
 }
 
-
 # -------------------------------------------------------------------
 sub mk_name {
     my ($basename, $type, $scope, $critical) = @_;
@@ -201,12 +239,17 @@ sub mk_name {
 }
 
 1;
-__END__
 
-=head1 NAME
+# -------------------------------------------------------------------
+
+=pod
 
-SQL::Translator::Producer::SQLite - SQLite-specific producer for SQL::Translator
+=head1 SEE ALSO
+
+SQL::Translator, http://www.sqlite.org/.
 
 =head1 AUTHOR
 
-Ken Y. Clark E<lt>kclark@cpan.orgE<gt>
+Ken Y. Clark E<lt>kclark@cpan.orgE<gt>.
+
+=cut