File: README

package info (click to toggle)
libsql-translator-perl 0.11024-1
  • links: PTS, VCS
  • area: main
  • in suites: buster, sid
  • size: 4,572 kB
  • sloc: perl: 67,471; sql: 3,809; xml: 258; makefile: 2
file content (395 lines) | stat: -rw-r--r-- 14,649 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
NAME
    SQL::Translator - manipulate structured data definitions (SQL and more)

SYNOPSIS
      use SQL::Translator;

      my $translator          = SQL::Translator->new(
          # Print debug info
          debug               => 1,
          # Print Parse::RecDescent trace
          trace               => 0,
          # Don't include comments in output
          no_comments         => 0,
          # Print name mutations, conflicts
          show_warnings       => 0,
          # Add "drop table" statements
          add_drop_table      => 1,
          # to quote or not to quote, thats the question
          quote_identifiers     => 1,
          # Validate schema object
          validate            => 1,
          # Make all table names CAPS in producers which support this option
          format_table_name   => sub {my $tablename = shift; return uc($tablename)},
          # Null-op formatting, only here for documentation's sake
          format_package_name => sub {return shift},
          format_fk_name      => sub {return shift},
          format_pk_name      => sub {return shift},
      );

      my $output     = $translator->translate(
          from       => 'MySQL',
          to         => 'Oracle',
          # Or an arrayref of filenames, i.e. [ $file1, $file2, $file3 ]
          filename   => $file,
      ) or die $translator->error;

      print $output;

DESCRIPTION
    This documentation covers the API for SQL::Translator. For a more
    general discussion of how to use the modules and scripts, please see
    SQL::Translator::Manual.

    SQL::Translator is a group of Perl modules that converts vendor-specific
    SQL table definitions into other formats, such as other vendor-specific
    SQL, ER diagrams, documentation (POD and HTML), XML, and Class::DBI
    classes. The main focus of SQL::Translator is SQL, but parsers exist for
    other structured data formats, including Excel spreadsheets and
    arbitrarily delimited text files. Through the separation of the code
    into parsers and producers with an object model in between, it's
    possible to combine any parser with any producer, to plug in custom
    parsers or producers, or to manipulate the parsed data via the built-in
    object model. Presently only the definition parts of SQL are handled
    (CREATE, ALTER), not the manipulation of data (INSERT, UPDATE, DELETE).

CONSTRUCTOR
  new
    The constructor is called "new", and accepts a optional hash of options.
    Valid options are:

    *   parser / from

    *   parser_args

    *   producer / to

    *   producer_args

    *   filters

    *   filename / file

    *   data

    *   debug

    *   add_drop_table

    *   quote_identifiers

    *   quote_table_names (DEPRECATED)

    *   quote_field_names (DEPRECATED)

    *   no_comments

    *   trace

    *   validate

    All options are, well, optional; these attributes can be set via
    instance methods. Internally, they are; no (non-syntactical) advantage
    is gained by passing options to the constructor.

METHODS
  add_drop_table
    Toggles whether or not to add "DROP TABLE" statements just before the
    create definitions.

  quote_identifiers
    Toggles whether or not to quote identifiers (table, column, constraint,
    etc.) with a quoting mechanism suitable for the chosen Producer. The
    default (true) is to quote them.

  quote_table_names
    DEPRECATED - A legacy proxy to "quote_identifiers"

  quote_field_names
    DEPRECATED - A legacy proxy to "quote_identifiers"

  no_comments
    Toggles whether to print comments in the output. Accepts a true or false
    value, returns the current value.

  producer
    The "producer" method is an accessor/mutator, used to retrieve or define
    what subroutine is called to produce the output. A subroutine defined as
    a producer will be invoked as a function (*not a method*) and passed its
    container "SQL::Translator" instance, which it should call the "schema"
    method on, to get the "SQL::Translator::Schema" generated by the parser.
    It is expected that the function transform the schema structure to a
    string. The "SQL::Translator" instance is also useful for informational
    purposes; for example, the type of the parser can be retrieved using the
    "parser_type" method, and the "error" and "debug" methods can be called
    when needed.

    When defining a producer, one of several things can be passed in: A
    module name (e.g., "My::Groovy::Producer"), a module name relative to
    the "SQL::Translator::Producer" namespace (e.g., "MySQL"), a module name
    and function combination ("My::Groovy::Producer::transmogrify"), or a
    reference to an anonymous subroutine. If a full module name is passed in
    (for the purposes of this method, a string containing "::" is considered
    to be a module name), it is treated as a package, and a function called
    "produce" will be invoked: $modulename::produce. If $modulename cannot
    be loaded, the final portion is stripped off and treated as a function.
    In other words, if there is no file named
    My/Groovy/Producer/transmogrify.pm, "SQL::Translator" will attempt to
    load My/Groovy/Producer.pm and use "transmogrify" as the name of the
    function, instead of the default "produce".

      my $tr = SQL::Translator->new;

      # This will invoke My::Groovy::Producer::produce($tr, $data)
      $tr->producer("My::Groovy::Producer");

      # This will invoke SQL::Translator::Producer::Sybase::produce($tr, $data)
      $tr->producer("Sybase");

      # This will invoke My::Groovy::Producer::transmogrify($tr, $data),
      # assuming that My::Groovy::Producer::transmogrify is not a module
      # on disk.
      $tr->producer("My::Groovy::Producer::transmogrify");

      # This will invoke the referenced subroutine directly, as
      # $subref->($tr, $data);
      $tr->producer(\&my_producer);

    There is also a method named "producer_type", which is a string
    containing the classname to which the above "produce" function belongs.
    In the case of anonymous subroutines, this method returns the string
    "CODE".

    Finally, there is a method named "producer_args", which is both an
    accessor and a mutator. Arbitrary data may be stored in name => value
    pairs for the producer subroutine to access:

      sub My::Random::producer {
          my ($tr, $data) = @_;
          my $pr_args = $tr->producer_args();

          # $pr_args is a hashref.

    Extra data passed to the "producer" method is passed to "producer_args":

      $tr->producer("xSV", delimiter => ',\s*');

      # In SQL::Translator::Producer::xSV:
      my $args = $tr->producer_args;
      my $delimiter = $args->{'delimiter'}; # value is ,\s*

  parser
    The "parser" method defines or retrieves a subroutine that will be
    called to perform the parsing. The basic idea is the same as that of
    "producer" (see above), except the default subroutine name is "parse",
    and will be invoked as "$module_name::parse($tr, $data)". Also, the
    parser subroutine will be passed a string containing the entirety of the
    data to be parsed.

      # Invokes SQL::Translator::Parser::MySQL::parse()
      $tr->parser("MySQL");

      # Invokes My::Groovy::Parser::parse()
      $tr->parser("My::Groovy::Parser");

      # Invoke an anonymous subroutine directly
      $tr->parser(sub {
        my $dumper = Data::Dumper->new([ $_[1] ], [ "SQL" ]);
        $dumper->Purity(1)->Terse(1)->Deepcopy(1);
        return $dumper->Dump;
      });

    There is also "parser_type" and "parser_args", which perform analogously
    to "producer_type" and "producer_args"

  filters
    Set or retrieve the filters to run over the schema during the
    translation, before the producer creates its output. Filters are sub
    routines called, in order, with the schema object to filter as the 1st
    arg and a hash of options (passed as a list) for the rest of the args.
    They are free to do whatever they want to the schema object, which will
    be handed to any following filters, then used by the producer.

    Filters are set as an array, which gives the order they run in. Like
    parsers and producers, they can be defined by a module name, a module
    name relative to the SQL::Translator::Filter namespace, a module name
    and function name together or a reference to an anonymous subroutine.
    When using a module name a function called "filter" will be invoked in
    that package to do the work.

    To pass args to the filter set it as an array ref with the 1st value
    giving the filter (name or sub) and the rest its args. e.g.

     $tr->filters(
         sub {
            my $schema = shift;
            # Do stuff to schema here!
         },
         DropFKeys,
         [ "Names", table => 'lc' ],
         [ "Foo",   foo => "bar", hello => "world" ],
         [ "Filter5" ],
     );

    Although you normally set them in the constructor, which calls through
    to filters. i.e.

      my $translator  = SQL::Translator->new(
          ...
          filters => [
              sub { ... },
              [ "Names", table => 'lc' ],
          ],
          ...
      );

    See t/36-filters.t for more examples.

    Multiple set calls to filters are cumulative with new filters added to
    the end of the current list.

    Returns the filters as a list of array refs, the 1st value being a
    reference to the filter sub and the rest its args.

  show_warnings
    Toggles whether to print warnings of name conflicts, identifier
    mutations, etc. Probably only generated by producers to let the user
    know when something won't translate very smoothly (e.g., MySQL "enum"
    fields into Oracle). Accepts a true or false value, returns the current
    value.

  translate
    The "translate" method calls the subroutine referenced by the "parser"
    data member, then calls any "filters" and finally calls the "producer"
    sub routine (these members are described above). It accepts as arguments
    a number of things, in key => value format, including (potentially) a
    parser and a producer (they are passed directly to the "parser" and
    "producer" methods).

    Here is how the parameter list to "translate" is parsed:

    *   1 argument means it's the data to be parsed; which could be a string
        (filename) or a reference to a scalar (a string stored in memory),
        or a reference to a hash, which is parsed as being more than one
        argument (see next section).

          # Parse the file /path/to/datafile
          my $output = $tr->translate("/path/to/datafile");

          # Parse the data contained in the string $data
          my $output = $tr->translate(\$data);

    *   More than 1 argument means its a hash of things, and it might be
        setting a parser, producer, or datasource (this key is named
        "filename" or "file" if it's a file, or "data" for a SCALAR
        reference.

          # As above, parse /path/to/datafile, but with different producers
          for my $prod ("MySQL", "XML", "Sybase") {
              print $tr->translate(
                        producer => $prod,
                        filename => "/path/to/datafile",
                    );
          }

          # The filename hash key could also be:
              datasource => \$data,

        You get the idea.

  filename, data
    Using the "filename" method, the filename of the data to be parsed can
    be set. This method can be used in conjunction with the "data" method,
    below. If both the "filename" and "data" methods are invoked as
    mutators, the data set in the "data" method is used.

        $tr->filename("/my/data/files/create.sql");

    or:

        my $create_script = do {
            local $/;
            open CREATE, "/my/data/files/create.sql" or die $!;
            <CREATE>;
        };
        $tr->data(\$create_script);

    "filename" takes a string, which is interpreted as a filename. "data"
    takes a reference to a string, which is used as the data to be parsed.
    If a filename is set, then that file is opened and read when the
    "translate" method is called, as long as the data instance variable is
    not set.

  schema
    Returns the SQL::Translator::Schema object.

  trace
    Turns on/off the tracing option of Parse::RecDescent.

  validate
    Whether or not to validate the schema object after parsing and before
    producing.

  version
    Returns the version of the SQL::Translator release.

AUTHORS
    See the included AUTHORS file:
    <http://search.cpan.org/dist/SQL-Translator/AUTHORS>

GETTING HELP/SUPPORT
    If you are stuck with a problem or have doubts about a particular
    approach do not hesitate to contact us via any of the following options
    (the list is sorted by "fastest response time"):

    *   IRC: irc.perl.org#sql-translator

    *   Mailing list: <http://lists.scsys.co.uk/mailman/listinfo/dbix-class>

    *   RT Bug Tracker:
        <https://rt.cpan.org/NoAuth/Bugs.html?Dist=SQL-Translator>

HOW TO CONTRIBUTE
    Contributions are always welcome, in all usable forms (we especially
    welcome documentation improvements). The delivery methods include git-
    or unified-diff formatted patches, GitHub pull requests, or plain bug
    reports either via RT or the Mailing list. Contributors are generally
    granted access to the official repository after their first several
    patches pass successful review. Don't hesitate to contact us with any
    further questions you may have.

    This project is maintained in a git repository. The code and related
    tools are accessible at the following locations:

    *   Official repo:
        <git://git.shadowcat.co.uk/dbsrgits/SQL-Translator.git>

    *   Official gitweb:
        <http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=dbsrgits/SQL-Transla
        tor.git>

    *   GitHub mirror: <https://github.com/dbsrgits/SQL-Translator>

    *   Authorized committers:
        <ssh://dbsrgits@git.shadowcat.co.uk/sql-translator.git>

    *   Travis-CI log:
        <https://travis-ci.org/dbsrgits/sql-translator/builds>

COPYRIGHT
    Copyright 2012 the SQL::Translator authors, as listed in "AUTHORS".

LICENSE
    This library is free software and may be distributed under the same
    terms as Perl 5 itself.

PRAISE
    If you find this module useful, please use
    <http://cpanratings.perl.org/rate/?distribution=SQL-Translator> to rate
    it.

SEE ALSO
    perl, SQL::Translator::Parser, SQL::Translator::Producer,
    Parse::RecDescent, GD, GraphViz, Text::RecordParser, Class::DBI,
    XML::Writer.