Abstract access to Text::CSV_XS

Text::xVS was *WAY* too slow when dealing with "large" CSV files
(1MB-4MB). Switching to Text::CSV_XS will provide major speed benefits,
but the interface is different, and more cumbersome to access (always
having to pass a filehandle).

This class takes away the cumbersome and the changes required for the
switch of the CSV brains.
switch to App::ToSequel::CSV

Use the new CSV parsing module.
Spec out attributes/methods

Start specing out the attributes that will be used to make the datatype
conversion pluggable.
Breakout @Basic into separate modules

@Basic does more than I need it to.
Add detect option for datatypes.
Determine data type while calculating length

While looping through the data to figure out the maximum length of the
data, parse the row with DateTime::Format::Natural, compare for all
digits and lastly check for words and whitespace.
new Default database class

This is for use when no engine is specified on the command line options.
It basicallys defaults to whatever methods are in the DB class.
Add more data type handlers

Add documentation for the numeric data types, and add handlers for date,
timestamp,  and varchar.
Proper class and db attribute

Make this into a proper class with package definition and new method.
Add the db attribute that defauls to the Default DB engine if none is
specified.
Access the DB engine object.

Going to need to access this class from each command.
Pass options through ddl method.

Need to be able to know if the command line option to detect data types
has been set, so pass along all options to the ddl method.
Test for detected data type in DDL.
Create varchar method for Oracle.

Because you know, varchar can't just be varchar in Oracle, has to be
varchar2...
Add precision to numeric detection

While determining data types, check to see the length of the decimal
places and add it to the column data structure.
Add milliseconds to timestamps

Detection of data types should include timestamps that have a
millisecond portion.

There was a previous commit that introduced the millisecond to the test
data, this is the detection routines to handle it.
Date format test

Another date format to try with detection.
performance improvements via limits and reorg

There are issues with the datatype detection and large files. 27,000
rows takes a long time to determine what the datatypes are. I think it
has to do with the date checking, but still need further investigation.
As a stop gap, I have included a new option to limit the sample size of
the data to 500 rows.

This doesn't impact the length determination as that's handled
separately, however it can impact the percision of numbers. Knowing the
data being parsed is key.
Increase default sample size

During testing on a real implementation it only took a couple of seconds
to do 2800 rows, so setting the default sample size to 2000 shouldn't be
an issue.
Make use of the precision attribute in numerics

Previous the precision was ignored (also because the parameter had a
typo in it but let's ignore that). Now the numeric handler will add the
precision to the declaration and test to ensure that it is set.

Additional test data for numerics without precision, and differnt date
style added.
precision on a number is optional

An Integer doesn't not have a precision, as such when checking a column
for a numeric type, the precision should be an option in the regex.

Having changed to an optional though, it must be defined before it can
be used in a comparison.