ydbi 0.5.2 → 0.5.7

data/lib/dbd/sqlite/database.rb

@@ -0,0 +1,151 @@
+#
+# See DBI::BaseDatabase.
+#
+class DBI::DBD::SQLite::Database < DBI::BaseDatabase
+    attr_reader :db
+    attr_reader :attr_hash
+    attr_accessor :open_handles
+
+    #
+    # Constructor. Valid attributes:
+    #
+    # * AutoCommit: Commit after every statement execution.
+    #
+    def initialize(dbname, user, auth, attr_hash)
+        # FIXME why isn't this crap being done in DBI?
+        unless dbname.kind_of? String
+            raise DBI::InterfaceError, "Database Name must be a string"
+        end
+
+        unless dbname.length > 0
+            raise DBI::InterfaceError, "Database Name needs to be length > 0"
+        end
+
+        unless attr_hash.kind_of? Hash
+            raise DBI::InterfaceError, "Attributes should be a hash"
+        end
+
+        # FIXME handle busy_timeout in SQLite driver
+        # FIXME handle SQLite pragmas in SQLite driver
+        @attr_hash = attr_hash
+        @open_handles = 0
+
+        self["AutoCommit"] = true if self["AutoCommit"].nil?
+
+        # open the database
+        begin
+            @db = ::SQLite::Database.new(dbname)
+        rescue Exception => e
+            raise DBI::OperationalError, "Couldn't open database #{dbname}: #{e.message}"
+        end
+    end
+
+    def disconnect
+        rollback rescue nil
+        @db.close if @db and !@db.closed?
+        @db = nil
+    end
+
+    def database_name
+        st = DBI::DBD::SQLite::Statement.new('PRAGMA database_list', self)
+        st.execute
+        row = st.fetch
+        st.finish
+
+        return row[2]
+    end
+
+    def prepare(stmt)
+        return DBI::DBD::SQLite::Statement.new(stmt, self)
+    end
+
+    def ping
+        return !@db.closed?
+    end
+
+    def tables
+        sth = prepare("select name from sqlite_master where type in ('table', 'view')")
+        sth.execute
+        tables = sth.fetch_all.flatten
+        sth.finish
+        return tables
+        # FIXME does sqlite use views too? not sure, but they need to be included according to spec
+    end
+
+    def commit
+        @db.commit if @db.transaction_active?
+    end
+
+    #
+    # Rollback the transaction. SQLite has some issues with open statement
+    # handles when this happens. If there are still open handles, a
+    # DBI::Warning exception will be raised.
+    #
+    def rollback
+        if @open_handles > 0
+            raise DBI::Warning, "Leaving unfinished select statement handles while rolling back a transaction can corrupt your database or crash your program"
+        end
+
+        @db.rollback if @db.transaction_active?
+    end
+
+    def [](key)
+        return @attr_hash[key]
+    end
+
+    #
+    # See DBI::BaseDatabase#[]=.
+    #
+    # If AutoCommit is set to +true+ using this method, was previously +false+,
+    # and we are currently in a transaction, The act of setting this will cause
+    # an immediate commit.
+    #
+    def []=(key, value)
+
+        old_value = @attr_hash[key]
+
+        @attr_hash[key] = value
+
+        # special handling of settings
+        case key
+        when "AutoCommit"
+            # if the value being set is true and the previous value is false,
+            # commit the current transaction (if any)
+            # FIXME I still think this is a horrible way of handling this.
+            if value and !old_value
+                begin 
+                    @dbh.commit
+                rescue Exception => e
+                end
+            end
+        end
+
+        return @attr_hash[key]
+    end
+
+    def columns(tablename)
+        return nil unless tablename and tablename.kind_of? String
+
+        sth = prepare("PRAGMA table_info(?)")
+        sth.bind_param(1, tablename)
+        sth.execute
+        columns = [ ]
+        while row = sth.fetch
+            column = { }
+            column["name"] = row[1]
+
+            m = DBI::DBD::SQLite.parse_type(row[2])
+            column["type_name"] = m[1]
+            column["precision"] = m[3].to_i if m[3]
+            column["scale"]     = m[5].to_i if m[5]
+
+            column["nullable"]  = row[3].to_i == 0
+            column["default"]   = row[4]
+            columns.push column
+        end
+
+        sth.finish
+        return columns
+        # XXX it'd be nice if the spec was changed to do this k/v with the name as the key.
+    end
+end

data/lib/dbd/sqlite/statement.rb

@@ -0,0 +1,125 @@
+#
+# See DBI::BaseStatement.
+#
+class DBI::DBD::SQLite::Statement < DBI::BaseStatement
+    DBI_TYPE_MAP = [
+        [ /^INT(EGER)?$/i,          DBI::SQL_INTEGER ],
+        [ /^(OID|ROWID|_ROWID_)$/i, DBI::SQL_OTHER   ],
+        [ /^FLOAT$/i,               DBI::SQL_FLOAT   ],
+        [ /^REAL$/i,                DBI::SQL_REAL    ],
+        [ /^DOUBLE$/i,              DBI::SQL_DOUBLE  ],
+        [ /^DECIMAL/i,              DBI::SQL_DECIMAL ],
+        [ /^(BOOL|BOOLEAN)$/i,      DBI::SQL_BOOLEAN ], 
+        [ /^TIME$/i,                DBI::SQL_TIME    ],
+        [ /^DATE$/i,                DBI::SQL_DATE    ],
+        [ /^TIMESTAMP$/i,           DBI::SQL_TIMESTAMP ], 
+        [ /^(VARCHAR|TEXT)/i,       DBI::SQL_VARCHAR ],
+        [ /^CHAR$/i,                DBI::SQL_CHAR    ],
+    ]
+
+    def initialize(stmt, dbh)
+        @dbh       = dbh
+        @statement = DBI::SQL::PreparedStatement.new(@dbh, stmt)
+        @attr      = { }
+        @params    = [ ]
+        @rows      = [ ]
+        @result_set = nil
+        @dbh.open_handles += 1
+    end
+
+    #
+    # See DBI::BaseStatement#bind_param. This method will also raise
+    # DBI::InterfaceError if +param+ is not a Fixnum, to prevent incorrect
+    # binding.
+    #
+    def bind_param(param, value, attributes=nil)
+        unless param.kind_of? Fixnum
+            raise DBI::InterfaceError, "Only numeric parameters are supported"
+        end
+
+        @params[param-1] = value
+
+        # FIXME what to do with attributes? are they important in SQLite?
+    end
+
+    #
+    # See DBI::BaseStatement#execute.
+    #
+    # In the event AutoCommit is off and no transaction is currently executing,
+    # one will be opened at this point. It is your responsibility to #finish,
+    # #cancel, #rollback, or #commit.
+    #
+    def execute
+        sql = @statement.bind(@params)
+        # XXX sqlite re-escapes this for us automatically, it's causing trouble with everything else.
+        #     this will probably break in a horrible manner and I will be forced to "fix" it again.
+        sql.gsub!(/\\\\/) { '\\' } 
+        DBI::DBD::SQLite.check_sql(sql)
+
+        begin
+            unless @dbh.db.transaction_active?
+                @dbh.db.transaction 
+            end
+            @result_set = @dbh.db.query(sql)
+            @dbh.commit if @dbh["AutoCommit"]
+        rescue Exception => e
+            raise DBI::DatabaseError, e.message
+        end
+    end
+
+    alias :finish :cancel
+
+    def finish
+        # nil out the result set
+        @result_set.close if @result_set
+        @result_set = nil
+        @rows = nil
+        @dbh.open_handles -= 1
+    end
+
+    def fetch
+        return nil if @result_set.eof?
+
+        row = @result_set.next
+        return nil unless row
+
+        return row
+    end
+
+    def column_info
+        columns = [ ]
+
+        # FIXME this shit should *really* be abstracted into DBI
+        # FIXME this still doesn't handle nullable/unique/default stuff.
+        @result_set.columns.each_with_index do |name, i|
+            columns[i] = { } unless columns[i]
+            columns[i]["name"] = name
+            type_name = @result_set.types[i]
+
+            if type_name
+                m = DBI::DBD::SQLite.parse_type(type_name)
+
+                columns[i]["type_name"] = m[1]
+                columns[i]["precision"] = m[3].to_i if m[3]
+                columns[i]["scale"]     = m[5].to_i if m[5]
+                DBI_TYPE_MAP.each do |map|
+                    if columns[i]["type_name"] =~ map[0]
+                        columns[i]["sql_type"] = map[1]
+                        break
+                    end
+                end
+
+                case columns[i]["type_name"]
+                when 'double'
+                    columns[i]["dbi_type"] = DBI::Type::Float
+                end
+            end
+        end
+
+        return columns
+    end
+
+    def rows
+        return @dbh.db.changes
+    end
+end

data/lib/dbd/sqlite3/database.rb

@@ -0,0 +1,201 @@
+#
+# See DBI::BaseDatabase.
+#
+class DBI::DBD::SQLite3::Database < DBI::BaseDatabase
+    #
+    # Constructor. Valid attributes:
+    #
+    # * AutoCommit: Commit after every statement execution.
+    #
+    # The following attributes go directly to the low-level SQLite3 driver. 
+    # Please consult it's documentation for more information.
+    #
+    # * auto_vacuum
+    # * cache_size
+    # * default_cache_size
+    # * default_synchronous
+    # * default_temp_store
+    # * full_column_names
+    # * synchronous
+    # * temp_store
+    # * type_translation
+    #
+    def initialize(dbname, attr)
+        @db = ::SQLite3::Database.new(dbname)
+
+        @db.type_translation = false
+
+        @attr = {'AutoCommit' => true}
+        if attr then
+            attr.each_pair do |key, value|
+                begin
+                    self[key] = value
+                rescue DBI::NotSupportedError
+                end
+            end
+        end
+        __generate_attr__
+    end
+
+    def disconnect()
+        @db.rollback if @db.transaction_active?
+        @db.close
+    end
+
+    def prepare(statement)
+        DBI::DBD::SQLite3::Statement.new(statement, @db)
+    end
+
+    def database_name
+        st = DBI::DBD::SQLite3::Statement.new('PRAGMA database_list', @db)
+        st.execute
+        row = st.fetch
+        st.finish
+
+        return row[2]
+    end
+
+    def ping()
+        not @db.closed?
+    end
+
+    def commit()
+        if @db.transaction_active?
+            @db.commit
+            @db.transaction
+        else
+            raise DBI::ProgrammingError.new("No active transaction.")
+        end
+    end
+
+    #
+    # See DBI::BaseDatabase#rollback.
+    #
+    # If all statements were not closed before the rollback occurs, a
+    # DBI::Warning may be raised if the database encounters an error because of
+    # it.
+    #
+    # This method will also raise DBI::ProgrammingError if not in a
+    # transaction.
+    #
+    def rollback()
+        if @db.transaction_active?
+            begin 
+                @db.rollback 
+                @db.transaction
+            rescue Exception => e
+                raise DBI::Warning, "Statements were not closed prior to rollback"
+            end
+        else
+            raise DBI::ProgrammingError.new("No active transaction.")
+        end
+    end
+
+    def tables()
+        ret = []
+        result = @db.execute(%q(
+            SELECT name FROM sqlite_master WHERE type IN ('table', 'view') 
+            UNION ALL 
+            SELECT name FROM sqlite_temp_master WHERE type in ('table', 'view') ORDER BY 1
+        ))
+        result.each{|row| ret.push(row[0])}
+        ret
+    end
+
+    #
+    # See DBI::BaseDatabase#columns.
+    #
+    # Additional Attributes:
+    #
+    # * sql_type: XOPEN integer SQL Type.
+    # * nullable: true if NULL is allowed in this column.
+    # * default: the value that will be used in new rows if this column
+    #   receives no data.
+    #
+    def columns(table)
+        @db.type_translation = false
+        ret =
+            @db.table_info(table).map do |hash|
+                m = DBI::DBD::SQLite3.parse_type(hash['type'])
+                h = { 
+                    'name' => hash['name'],
+                    'type_name' => m[1],
+                    'sql_type' => 
+                        begin
+                            DBI.const_get('SQL_'+hash['type'].upcase)
+                        rescue NameError
+                            DBI::SQL_OTHER
+                        end,
+                    'nullable' => (hash['notnull'] == '0'),
+                    'default' => (@attr['type_translation'] && (not hash['dflt_value'])) ? 
+                                    @db.translator.translate(hash['type'], hash['dflt_value']) :
+                                    hash['dflt_value'] 
+                }
+
+                h['precision'] = m[3].to_i if m[3]
+                h['scale']     = m[5].to_i if m[5]
+
+                h
+            end
+        @db.type_translation = @attr['type_translation']
+        ret
+    end
+
+    def quote(value)
+        ::SQLite3::Database.quote(value.to_s)
+    end
+
+    #
+    # This method is used to aid the constructor and probably should not be
+    # used independently.
+    #
+    def __generate_attr__()
+        tt = @db.type_translation
+        @db.type_translation = false
+        [ 'auto_vacuum', 'cache_size', 'default_cache_size',
+        'default_synchronous', 'default_temp_store', 'full_column_names',
+        'synchronous', 'temp_store', 'type_translation' ].each do |key|
+            unless @attr.has_key?(key) then
+                @attr[key] = @db.__send__(key)
+            end
+        end
+        @db.type_translation = tt
+    end
+
+    #
+    # See #new for valid attributes.
+    #
+    # If Autocommit is set to true, commit happens immediately if a transaction
+    # is open.
+    #
+    def []=(attr, value)
+        case attr
+        when 'AutoCommit'
+            if value
+                @db.commit if @db.transaction_active?
+            else
+                @db.transaction unless @db.transaction_active?
+            end
+        @attr[attr] = value
+        when 'auto_vacuum', 'cache_size', 'count_changes',
+          'default_cache_size', 'encoding', 'full_column_names',
+          'page_size', 'short_column_names', 'synchronous',
+          'temp_store', 'temp_store_directory'
+          @db.__send__((attr+'='), value)
+            @attr[attr] = @db.__send__(attr)
+        when 'busy_timeout'
+            @db.busy_timeout(value)
+            @attr[attr] = value
+        when 'busy_handler'
+            @db.busy_timeout(&value)
+            @attr[attr] = value
+        when 'type_translation'
+            @db.type_translation = value
+            @attr[attr] = value
+        else
+            raise DBI::NotSupportedError
+        end
+
+        return value
+    end
+end