class SQLite3::Translator

translator instance (Database#translator).
by registering translator blocks with the corresponding database’s
Further, applications may define their own custom type translation logic
translation (Database#type_translation).
instance may have a Translator instance, in order to assist in type
converting string data to a value of some specified type. Every Database
The Translator class encapsulates the logic and callbacks necessary for

def add_translator(type, &block) # :yields: type, value

:yields: type, value
The block should return the translated value.

is the (string) data to convert.
type is translated based on the additional data. The "value" parameter
parentheses), so the block itself may include logic for changing how a
"value". In this case, the "type" is the full type name (including
The translator block itself should accept two parameters, "type" and

are made solely on the "base" type name.
information is stripped off and discarded, so type translation decisions
may include parentheses (i.e., "VARCHAR(30)"). However, any parenthetical
translations to the given type. The type should be an SQL datatype, and
Add a new translator block, which will be invoked to process type 
def add_translator(type, &block) # :yields: type, value
  @translators[ type_name(type) ] = block
end

def initialize

translators for most SQL data types.
Create a new Translator instance. It will be preinitialized with default 
def initialize
  @translators = Hash.new(proc { |type, value| value })
  @type_name_cache = {}
  register_default_translators
end

def register_default_translators

This includes translators for most major SQL data types.
Register the default translators for the current Translator instance. 
def register_default_translators
  [ "time",
    "timestamp" ].each { |type| add_translator(type) { |t, v| Time.parse(v) } }
  add_translator("date") { |t,v| Date.parse(v) }
  add_translator("datetime") { |t,v| DateTime.parse(v) }
  [ "decimal",
    "float",
    "numeric",
    "double",
    "real",
    "dec",
    "fixed" ].each { |type| add_translator(type) { |t,v| v.to_f } }
  [ "integer",
    "smallint",
    "mediumint",
    "int",
    "bigint" ].each { |type| add_translator(type) { |t,v| v.to_i } }
  [ "bit",
    "bool",
    "boolean" ].each do |type|
    add_translator(type) do |t,v|
      !(v.strip.gsub(/00+/,"0") == "0" ||
        v.downcase == "false" ||
        v.downcase == "f" ||
        v.downcase == "no" ||
        v.downcase == "n")
    end
  end
  add_translator("tinyint") do |type, value|
    if type =~ /\(\s*1\s*\)/
      value.to_i == 1
    else
      value.to_i
    end
  end
end

def translate(type, value)

and are always passed straight through regardless of the type parameter.
itself is always returned. Further, +nil+ values are never translated,
absense of an installed translator block for the given type, the value
Translate the given string value to a value of the given type. In the 
def translate(type, value)
  unless value.nil?
    @translators[ type_name(type) ].call(type, value)
  end
end

def type_name(type)

type name, without any parenthetical data.
A convenience method for working with type names. This returns the "base" 
def type_name(type)
  @type_name_cache[type] ||= begin
                               type = "" if type.nil?
                               type = $1 if type =~ /^(.*?)\(/
                               type.upcase
                             end
end