knjrbfw 0.0.110 → 0.0.111

data/lib/knj/knjdb/dump.rb

@@ -1,122 +0,0 @@
-#This class can be used to make SQL-dumps of databases, tables or however you want it.
-class Knj::Db::Dump
-  #Constructor.
-  #===Examples
-  # dump = Knj::Db::Dump.new(:db => db)
-  def initialize(args)
-    @args = args
-    @debug = @args[:debug]
-  end
-  
-  #Method used to update the status.
-  def update_status
-    return nil if !@on_status
-    rows_count = Knj::Locales.number_out(@rows_count, 0)
-    rows_count_total = Knj::Locales.number_out(@rows_count_total, 0)
-    percent = (@rows_count.to_f / @rows_count_total.to_f) * 100
-    percent_text = Knj::Locales.number_out(percent, 1)
-    @on_status.call(:text => "Dumping table: '#{@table_obj.name}' (#{rows_count}/#{rows_count_total} - #{percent_text}%).")
-  end
-  
-  #Dumps all tables into the given IO.
-  def dump(io)
-    print "Going through tables.\n" if @debug
-    @rows_count = 0
-    
-    if @args[:tables]
-      tables = @args[:tables]
-    else
-      tables = @args[:db].tables.list.values
-    end
-    
-    if @on_status
-      @on_status.call(:text => "Preparing.")
-      
-      @rows_count_total = 0
-      tables.each do |table_obj|
-        @rows_count_total += table_obj.rows_count
-      end
-    end
-    
-    tables.each do |table_obj|
-      table_obj = @args[:db].tables[table_obj] if table_obj.is_a?(String) or table_obj.is_a?(Symbol)
-      next if table_obj.native?
-      
-      #Figure out keys.
-      @keys = []
-      table_obj.columns do |col|
-        @keys << col.name
-      end
-      
-      @table_obj = table_obj
-      self.update_status
-      print "Dumping table: '#{table_obj.name}'.\n" if @debug
-      self.dump_table(io, table_obj)
-    end
-  end
-  
-  #A block can be executed when a new status occurs.
-  def on_status(&block)
-    @on_status = block
-  end
-  
-  #Dumps the given table into the given IO.
-  def dump_table(io, table_obj)
-    #Get SQL for creating table and add it to IO.
-    sqls = @args[:db].tables.create(table_obj.name, table_obj.data, :return_sql => true)
-    sqls.each do |sql|
-      io.write("#{sql};\n")
-    end
-    
-    
-    #Try to find a primary column in the table.
-    prim_col = nil
-    table_obj.columns do |col|
-      if col.primarykey?
-        prim_col = col
-        break
-      end
-    end
-    
-    
-    #Set up rows and way to fill rows.
-    rows = []
-    block_data = proc do |row|
-      rows << row
-      @rows_count += 1
-      
-      if rows.length >= 1000
-        self.update_status
-        self.dump_insert_multi(io, table_obj, rows)
-      end
-    end
-    
-    
-    #If a primary column is found then use IDQuery. Otherwise use cloned unbuffered query.
-    args = {:idquery => prim_col.name.to_sym} if prim_col
-    
-    
-    #Clone the connecting with array-results and execute query.
-    @args[:db].clone_conn(:result => "array") do |db|
-      db.select(table_obj.name, nil, args, &block_data)
-    end
-    
-    
-    #Dump the last rows if any.
-    self.dump_insert_multi(io, table_obj, rows) if !rows.empty?
-  end
-  
-  #Dumps the given rows from the given table into the given IO.
-  def dump_insert_multi(io, table_obj, rows)
-    print "Inserting #{rows.length} into #{table_obj.name}.\n" if @debug
-    sqls = @args[:db].insert_multi(table_obj.name, rows, :return_sql => true, :keys => @keys)
-    sqls.each do |sql|
-      io.write("#{sql};\n")
-    end
-    
-    rows.clear
-    
-    #Ensure garbage collection or we might start using A LOT of memory.
-    GC.start
-  end
-end

data/lib/knj/knjdb/idquery.rb

@@ -1,109 +0,0 @@
-#This class takes a lot of IDs and runs a query against them.
-class Knj::Db::Idquery
-  #An array containing all the IDs that will be looked up.
-  attr_reader :ids
-  
-  #Constructor.
-  #===Examples
-  # idq = Knj::Db::Idquery(:db => db, :table => :users)
-  # idq.ids + [1, 5, 9]
-  # idq.each do |user|
-  #   print "Name: #{user[:name]}\n"
-  # end
-  def initialize(args, &block)
-    @args = args
-    @ids = []
-    @debug = @args[:debug]
-    
-    if @args[:query]
-      @args[:db].q(@args[:query]) do |data|
-        @args[:col] = data.keys.first if !@args[:col]
-        
-        if data.is_a?(Array)
-          @ids << data.first
-        else
-          @ids << data[@args[:col]]
-        end
-      end
-    end
-    
-    @args[:col] = :id if !@args[:col]
-    @args[:size] = 200 if !@args[:size]
-    
-    if block
-      raise "No query was given but a block was." if !@args[:query]
-      self.each(&block)
-    end
-  end
-  
-  #Fetches results.
-  #===Examples
-  # data = idq.fetch #=> Hash
-  def fetch
-    return nil if !@args
-    
-    if @res
-      data = @res.fetch if @res
-      @res = nil if !data
-      return data if data
-    end
-    
-    @res = new_res if !@res
-    if !@res
-      destroy
-      return nil
-    end
-    
-    data = @res.fetch
-    if !data
-      destroy
-      return nil
-    end
-    
-    return data
-  end
-  
-  #Yields a block for every result.
-  #===Examples
-  # idq.each do |data|
-  #   print "Name: #{data[:name]}\n"
-  # end
-  def each
-    while data = self.fetch
-      yield(data)
-    end
-  end
-  
-  private
-  
-  #Spawns a new database-result to read from.
-  def new_res
-    table_esc = "`#{@args[:db].esc_table(@args[:table])}`"
-    col_esc = "`#{@args[:db].esc_col(@args[:col])}`"
-    ids = @ids.shift(@args[:size])
-    
-    if ids.empty?
-      destroy
-      return nil
-    end
-    
-    ids_sql = Knj::ArrayExt.join(
-      :arr => ids,
-      :callback => proc{|val| @args[:db].esc(val)},
-      :sep => ",",
-      :surr => "'"
-    )
-    
-    query_str = "SELECT * FROM #{table_esc} WHERE #{table_esc}.#{col_esc} IN (#{ids_sql})"
-    print "Query: #{query_str}\n" if @debug
-    
-    return @args[:db].q(query_str)
-  end
-  
-  #Removes all variables on the object. This is done when no more results are available.
-  def destroy
-    @args = nil
-    @ids = nil
-    @debug = nil
-  end
-end

data/lib/knj/knjdb/libknjdb.rb

@@ -1,797 +0,0 @@
-Knj.gem_require([:wref, :datet])
-
-#A wrapper of several possible database-types.
-#
-#===Examples
-# db = Knj::Db.new(:type => "mysql", :subtype => "mysql2", :db => "mysql", :user => "user", :pass => "password")
-# mysql_table = db.tables['mysql']
-# name = mysql_table.name
-# cols = mysql_table.columns
-#
-# db = Knj::Db.new(:type => "sqlite3", :path => "some_db.sqlite3")
-#
-# db.q("SELECT * FROM users") do |data|
-#   print data[:name]
-# end
-class Knj::Db
-  #Autoloader for subclasses..
-  def self.const_missing(name)
-    require "#{$knjpath}knjdb/#{name.to_s.downcase}.rb"
-    raise "Still not defined: '#{name}'." if !Knj::Db.const_defined?(name)
-    return Knj::Db.const_get(name)
-  end
-  
-  attr_reader :sep_col, :sep_table, :sep_val, :opts, :conn, :conns, :int_types
-  
-  def initialize(opts)
-    require "#{$knjpath}threadhandler"
-    
-    self.setOpts(opts) if opts != nil
-    
-    @int_types = ["int", "bigint", "tinyint", "smallint", "mediumint"]
-    
-    if !@opts[:threadsafe]
-      require "monitor"
-      @mutex = Monitor.new
-    end
-    
-    @debug = @opts[:debug]
-    
-    self.conn_exec do |driver|
-      @sep_table = driver.sep_table
-      @sep_col = driver.sep_col
-      @sep_val = driver.sep_val
-      @esc_driver = driver
-    end
-  end
-  
-  def args
-    return @opts
-  end
-  
-  def setOpts(arr_opts)
-    @opts = {}
-    arr_opts.each do |key, val|
-      @opts[key.to_sym] = val
-    end
-    
-    if RUBY_PLATFORM == "java"
-      @opts[:subtype] = "java"
-    elsif @opts[:type] == "sqlite3" and RUBY_PLATFORM.index("mswin32") != nil
-      @opts[:subtype] = "ironruby"
-    end
-    
-    self.connect
-  end
-  
-  #Actually connects to the database. This is useually done automatically.
-  def connect
-    if @opts[:threadsafe]
-      @conns = Knj::Threadhandler.new
-      
-      @conns.on_spawn_new do
-        self.spawn
-      end
-      
-      @conns.on_inactive do |data|
-        data[:obj].close
-      end
-      
-      @conns.on_activate do |data|
-        data[:obj].reconnect
-      end
-    else
-      @conn = self.spawn
-    end
-  end
-  
-  #Spawns a new driver (useally done automatically).
-  #===Examples
-  # driver_instance = db.spawn
-  def spawn
-    raise "No type given (#{@opts.keys.join(",")})." if !@opts[:type]
-    
-    fpaths = [
-      "drivers/#{@opts[:type]}/knjdb_#{@opts[:type]}.rb",
-      "libknjdb_#{@opts[:type]}.rb"
-    ]
-    fpaths.each do |fpath|
-      rpath = "#{File.dirname(__FILE__)}/#{fpath}"
-      
-      if (!@opts.key?(:require) or @opts[:require]) and File.exists?(rpath)
-        require rpath
-        break
-      end
-    end
-    
-    return Kernel.const_get("KnjDB_#{@opts[:type]}").new(self)
-  end
-  
-  #Registers a driver to the current thread.
-  def get_and_register_thread
-    raise "KnjDB-object is not in threadding mode." if !@conns
-    
-    thread_cur = Thread.current
-    tid = self.__id__
-    thread_cur[:knjdb] = {} if !thread_cur[:knjdb]
-    
-    if thread_cur[:knjdb][tid]
-      #An object has already been spawned - free that first to avoid endless "used" objects.
-      self.free_thread
-    end
-    
-    thread_cur[:knjdb][tid] = @conns.get_and_lock if !thread_cur[:knjdb][tid]
-    
-    #If block given then be ensure to free thread after yielding.
-    if block_given?
-      begin
-        yield
-      ensure
-        self.free_thread
-      end
-    end
-  end
-  
-  #Frees the current driver from the current thread.
-  def free_thread
-    thread_cur = Thread.current
-    tid = self.__id__
-    
-    if thread_cur[:knjdb] and thread_cur[:knjdb].key?(tid)
-      db = thread_cur[:knjdb][tid]
-      thread_cur[:knjdb].delete(tid)
-      @conns.free(db) if @conns
-    end
-  end
-  
-  #Clean up various memory-stuff if possible.
-  def clean
-    if @conns
-      @conns.objects.each do |data|
-        data[:object].clean if data[:object].respond_to?("clean")
-      end
-    elsif @conn
-      @conn.clean if @conn.respond_to?("clean")
-    end
-  end
-  
-  #The all driver-database-connections.
-  def close
-    @conn.close if @conn
-    @conns.destroy if @conns
-    
-    @conn = nil
-    @conns = nil
-  end
-  
-  #Clones the current database-connection with possible extra arguments.
-  def clone_conn(args = {})
-    conn = Knj::Db.new(@opts.clone.merge(args))
-    
-    if block_given?
-      begin
-        yield(conn)
-      ensure
-        conn.close
-      end
-      
-      return nil
-    else
-      return conn
-    end
-  end
-  
-  #Copies the content of the current database to another instance of Knj::Db.
-  def copy_to(db, args = {})
-    data["tables"].each do |table|
-      table_args = nil
-      table_args = args["tables"][table["name"].to_s] if args and args["tables"] and args["tables"][table["name"].to_s]
-      next if table_args and table_args["skip"]
-      table.delete("indexes") if table.key?("indexes") and args["skip_indexes"]
-      db.tables.create(table["name"], table)
-      
-      limit_from = 0
-      limit_incr = 1000
-      
-      loop do
-        ins_arr = []
-        q_rows = self.select(table["name"], {}, {"limit_from" => limit_from, "limit_to" => limit_incr})
-        while d_rows = q_rows.fetch
-          col_args = nil
-          
-          if table_args and table_args["columns"]
-            d_rows.each do |col_name, col_data|
-              col_args = table_args["columns"][col_name.to_s] if table_args and table_args["columns"]
-              d_rows[col_name] = "" if col_args and col_args["empty"]
-            end
-          end
-          
-          ins_arr << d_rows
-        end
-        
-        break if ins_arr.empty?
-        
-        db.insert_multi(table["name"], ins_arr)
-        limit_from += limit_incr
-      end
-    end
-  end
-  
-  #Returns the data of this database in a hash.
-  #===Examples
-  # data = db.data
-  # tables_hash = data['tables']
-  def data
-    tables_ret = []
-    tables.list.each do |name, table|
-      tables_ret << table.data
-    end
-    
-    return {
-      "tables" => tables_ret
-    }
-  end
-  
-  #Simply inserts data into a table.
-  #
-  #===Examples
-  # db.insert(:users, {:name => "John", :lastname => "Doe"})
-  # id = db.insert(:users, {:name => "John", :lastname => "Doe"}, :return_id => true)
-  # sql = db.insert(:users, {:name => "John", :lastname => "Doe"}, :return_sql => true) #=> "INSERT INTO `users` (`name`, `lastname`) VALUES ('John', 'Doe')"
-  def insert(tablename, arr_insert, args = nil)
-    sql = "INSERT INTO #{@sep_table}#{tablename}#{@sep_table}"
-    
-    if !arr_insert or arr_insert.empty?
-      #This is the correct syntax for inserting a blank row in MySQL.
-      if @opts[:type].to_s == "mysql"
-        sql << " VALUES ()"
-      elsif @opts[:type].to_s == "sqlite3"
-        sql << " DEFAULT VALUES"
-      else
-        raise "Unknown database-type: '#{@opts[:type]}'."
-      end
-    else
-      sql << " ("
-      
-      first = true
-      arr_insert.each do |key, value|
-        if first
-          first = false
-        else
-          sql << ", "
-        end
-        
-        sql << "#{@sep_col}#{key}#{@sep_col}"
-      end
-      
-      sql << ") VALUES ("
-      
-      first = true
-      arr_insert.each do |key, value|
-        if first
-          first = false
-        else
-          sql << ", "
-        end
-        
-        sql << self.sqlval(value)
-      end
-      
-      sql << ")"
-    end
-    
-    return sql if args and args[:return_sql]
-    
-    self.conn_exec do |driver|
-      driver.query(sql)
-      return driver.lastID if args and args[:return_id]
-      return nil
-    end
-  end
-  
-  #Returns the correct SQL-value for the given value. If it is a number, then just the raw number as a string will be returned. nil's will be NULL and strings will have quotes and will be escaped.
-  def sqlval(val)
-    return @conn.sqlval(val) if @conn.respond_to?(:sqlval)
-    
-    if val.is_a?(Fixnum) or val.is_a?(Integer)
-      return val.to_s
-    elsif val == nil
-      return "NULL"
-    elsif val.is_a?(Date)
-      return "#{@sep_val}#{Datet.in(val).dbstr(:time => false)}#{@sep_val}"
-    elsif val.is_a?(Time) or val.is_a?(DateTime)
-      return "#{@sep_val}#{Datet.in(val).dbstr}#{@sep_val}"
-    else
-      return "#{@sep_val}#{self.escape(val)}#{@sep_val}"
-    end
-  end
-  
-  #Simply and optimal insert multiple rows into a table in a single query. Uses the drivers functionality if supported or inserts each row manually.
-  #
-  #===Examples
-  # db.insert_multi(:users, [
-  #   {:name => "John", :lastname => "Doe"},
-  #   {:name => "Kasper", :lastname => "Johansen"}
-  # ])
-  def insert_multi(tablename, arr_hashes, args = nil)
-    return false if arr_hashes.empty?
-    
-    if @esc_driver.respond_to?(:insert_multi)
-      if args and args[:return_sql]
-        return [@esc_driver.insert_multi(tablename, arr_hashes, args)]
-      end
-      
-      self.conn_exec do |driver|
-        return driver.insert_multi(tablename, arr_hashes, args)
-      end
-    else
-      ret = [] if args and (args[:return_id] or args[:return_sql])
-      arr_hashes.each do |hash|
-        if ret
-          ret << self.insert(tablename, hash, args)
-        else
-          self.insert(tablename, hash, args)
-        end
-      end
-      
-      if ret
-        return ret
-      else
-        return nil
-      end
-    end
-  end
-  
-  #Simple updates rows.
-  #
-  #===Examples
-  # db.update(:users, {:name => "John"}, {:lastname => "Doe"})
-  def update(tablename, arr_update, arr_terms = {}, args = nil)
-    raise "'arr_update' was not a hash." if !arr_update.is_a?(Hash)
-    return false if arr_update.empty?
-    
-    sql = ""
-    sql << "UPDATE #{@sep_col}#{tablename}#{@sep_col} SET "
-    
-    first = true
-    arr_update.each do |key, value|
-      if first
-        first = false
-      else
-        sql << ", "
-      end
-      
-      #Convert dates to valid dbstr.
-      value = self.date_out(value) if value.is_a?(Datet) or value.is_a?(Time)
-      
-      sql << "#{@sep_col}#{key}#{@sep_col} = "
-      sql << "#{@sep_val}#{@esc_driver.escape(value)}#{@sep_val}"
-    end
-    
-    if arr_terms and arr_terms.length > 0
-      sql << " WHERE #{self.makeWhere(arr_terms)}"
-    end
-    
-    return sql if args and args[:return_sql]
-    
-    self.conn_exec do |driver|
-      driver.query(sql)
-    end
-  end
-  
-  #Checks if a given selector exists. If it does, updates it to match data. If not inserts the row.
-  def upsert(table, selector, data)
-    row = self.select(table, selector, "limit" => 1).fetch
-    
-    if row
-      self.update(table, data, row)
-    else
-      self.insert(table, selector.merge(data))
-    end
-  end
-  
-  #Makes a select from the given arguments: table-name, where-terms and other arguments as limits and orders. Also takes a block to avoid raping of memory.
-  def select(tablename, arr_terms = nil, args = nil, &block)
-    #Set up vars.
-    sql = ""
-    args_q = nil
-    select_sql = "*"
-    
-    #Give 'cloned_ubuf' argument to 'q'-method.
-    if args and args[:cloned_ubuf]
-      args_q = {:cloned_ubuf => true}
-    end
-    
-    #Set up IDQuery-stuff if that is given in arguments.
-    if args and args[:idquery]
-      if args[:idquery] == true
-        select_sql = "`id`"
-        col = :id
-      else
-        select_sql = "`#{self.esc_col(args[:idquery])}`"
-        col = args[:idquery]
-      end
-    end
-    
-    sql = "SELECT #{select_sql} FROM #{@sep_table}#{tablename}#{@sep_table}"
-    
-    if arr_terms != nil and !arr_terms.empty?
-      sql << " WHERE #{self.makeWhere(arr_terms)}"
-    end
-    
-    if args != nil
-      if args["orderby"]
-        sql << " ORDER BY #{args["orderby"]}"
-      end
-      
-      if args["limit"]
-        sql << " LIMIT #{args["limit"]}"
-      end
-      
-      if args["limit_from"] and args["limit_to"]
-        raise "'limit_from' was not numeric: '#{args["limit_from"]}'." if !(Float(args["limit_from"]) rescue false)
-        raise "'limit_to' was not numeric: '#{args["limit_to"]}'." if !(Float(args["limit_to"]) rescue false)
-        sql << " LIMIT #{args["limit_from"]}, #{args["limit_to"]}"
-      end
-    end
-    
-    #Do IDQuery if given in arguments.
-    if args and args[:idquery]
-      res = Knj::Db::Idquery.new(:db => self, :table => tablename, :query => sql, :col => col, &block)
-    else
-      res = self.q(sql, args_q, &block)
-    end
-    
-    #Return result if a block wasnt given.
-    if block
-      return nil
-    else
-      return res
-    end
-  end
-  
-  #Returns a single row from a database.
-  #
-  #===Examples
-  # row = db.single(:users, {:lastname => "Doe"})
-  def single(tablename, arr_terms = nil, args = {})
-    args["limit"] = 1
-    
-    #Experienced very weird memory leak if this was not done by block. Maybe bug in Ruby 1.9.2? - knj
-    self.select(tablename, arr_terms, args) do |data|
-      return data
-    end
-    
-    return false
-  end
-  
-  alias :selectsingle :single
-  
-  #Deletes rows from the database.
-  #
-  #===Examples
-  # db.delete(:users, {:lastname => "Doe"})
-  def delete(tablename, arr_terms, args = nil)
-    sql = "DELETE FROM #{@sep_table}#{tablename}#{@sep_table}"
-    
-    if arr_terms != nil and !arr_terms.empty?
-      sql << " WHERE #{self.makeWhere(arr_terms)}"
-    end
-    
-    return sql if args and args[:return_sql]
-    
-    self.conn_exec do |driver|
-      driver.query(sql)
-    end
-    
-    return nil
-  end
-  
-  #Internally used to generate SQL.
-  #
-  #===Examples
-  # sql = db.makeWhere({:lastname => "Doe"}, driver_obj)
-  def makeWhere(arr_terms, driver = nil)
-    sql = ""
-    
-    first = true
-    arr_terms.each do |key, value|
-      if first
-        first = false
-      else
-        sql << " AND "
-      end
-      
-      if value.is_a?(Array)
-        raise "Array for column '#{key}' was empty." if value.empty?
-        sql << "#{@sep_col}#{key}#{@sep_col} IN (#{Knj::ArrayExt.join(:arr => value, :sep => ",", :surr => "'", :callback => proc{|ele| self.esc(ele)})})"
-      elsif value.is_a?(Hash)
-        raise "Dont know how to handle hash."
-      else
-        sql << "#{@sep_col}#{key}#{@sep_col} = #{@sep_val}#{@esc_driver.escape(value)}#{@sep_val}"
-      end
-    end
-    
-    return sql
-  end
-  
-  #Returns a driver-object based on the current thread and free driver-objects.
-  #
-  #===Examples
-  # db.conn_exec do |driver|
-  #   str = driver.escape('something̈́')
-  # end
-  def conn_exec
-    if tcur = Thread.current and tcur[:knjdb]
-      tid = self.__id__
-      
-      if tcur[:knjdb].key?(tid)
-        yield(tcur[:knjdb][tid])
-        return nil
-      end
-    end
-    
-    if @conns
-      conn = @conns.get_and_lock
-      
-      begin
-        yield(conn)
-        return nil
-      ensure
-        @conns.free(conn)
-      end
-    elsif @conn
-      @mutex.synchronize do
-        yield(@conn)
-        return nil
-      end
-    end
-    
-    raise "Could not figure out how to find a driver to use?"
-  end
-  
-  #Executes a query and returns the result.
-  #
-  #===Examples
-  # res = db.query('SELECT * FROM users')
-  # while data = res.fetch
-  #   print data[:name]
-  # end
-  def query(string)
-    if @debug
-      print "SQL: #{string}\n"
-      
-      if @debug.is_a?(Fixnum) and @debug >= 2
-        print caller.join("\n")
-        print "\n"
-      end
-    end
-    
-    self.conn_exec do |driver|
-      return driver.query(string)
-    end
-  end
-  
-  #Execute an ubuffered query and returns the result.
-  #
-  #===Examples
-  # db.query_ubuf('SELECT * FROM users') do |data|
-  #   print data[:name]
-  # end
-  def query_ubuf(string, &block)
-    ret = nil
-    
-    self.conn_exec do |driver|
-      ret = driver.query_ubuf(string, &block)
-    end
-    
-    if block
-      ret.each(&block)
-      return nil
-    end
-    
-    return ret
-  end
-  
-  #Clones the connection, executes the given block and closes the connection again.
-  #
-  #===Examples
-  # db.cloned_conn do |conn|
-  #   conn.q('SELCET * FROM users') do |data|
-  #     print data[:name]
-  #   end
-  # end
-  def cloned_conn(args = nil, &block)
-    clone_conn_args = {
-      :threadsafe => false
-    }
-    
-    clone_conn_args.merge!(args[:clone_args]) if args and args[:clone_args]
-    dbconn = self.clone_conn(clone_conn_args)
-    
-    begin
-      yield(dbconn)
-    ensure
-      dbconn.close
-    end
-  end
-  
-  #Executes a query and returns the result. If a block is given the result is iterated over that block instead and it returns nil.
-  #
-  #===Examples
-  # db.q('SELECT * FROM users') do |data|
-  #   print data[:name]
-  # end
-  def q(str, args = nil, &block)
-    #If the query should be executed in a new connection unbuffered.
-    if args
-      if args[:cloned_ubuf]
-        raise "No block given." if !block
-        
-        self.cloned_conn(:clone_args => args[:clone_args]) do |cloned_conn|
-          ret = cloned_conn.query_ubuf(str)
-          ret.each(&block)
-        end
-        
-        return nil
-      else
-        raise "Invalid arguments given: '#{args}'."
-      end
-    end
-    
-    ret = self.query(str)
-    
-    if block
-      ret.each(&block)
-      return nil
-    end
-    
-    return ret
-  end
-  
-  #Yields a query-buffer and flushes at the end of the block given.
-  def q_buffer(&block)
-    Knj::Db::Query_buffer.new(:db => self, &block)
-    return nil
-  end
-  
-  #Returns the last inserted ID.
-  #
-  #===Examples
-  # id = db.last_id
-  def lastID
-    self.conn_exec do |driver|
-      return driver.lastID
-    end
-  end
-  
-  alias :last_id :lastID
-  
-  #Escapes a string to be safe-to-use in a query-string.
-  #
-  #===Examples
-  # db.q("INSERT INTO users (name) VALUES ('#{db.esc('John')}')")
-  def escape(string)
-    return @esc_driver.escape(string)
-  end
-  
-  alias :esc :escape
-  
-  #Escapes the given string to be used as a column.
-  def esc_col(str)
-    return @esc_driver.esc_col(str)
-  end
-  
-  #Escapes the given string to be used as a table.
-  def esc_table(str)
-    return @esc_driver.esc_table(str)
-  end
-  
-  #Returns a string which can be used in SQL with the current driver.
-  #===Examples
-  # str = db.date_out(Time.now) #=> "2012-05-20 22:06:09"
-  def date_out(date_obj = Datet.new, args = {})
-    if @esc_driver.respond_to?(:date_out)
-      return @esc_driver.date_out(date_obj, args)
-    end
-    
-    return Datet.in(date_obj).dbstr(args)
-  end
-  
-  #Takes a valid date-db-string and converts it into a Datet.
-  #===Examples
-  # db.date_in('2012-05-20 22:06:09') #=> 2012-05-20 22:06:09 +0200
-  def date_in(date_obj)
-    if @esc_driver.respond_to?(:date_in)
-      return @esc_driver.date_in(date_obj)
-    end
-    
-    return Datet.in(date_obj)
-  end
-  
-  #Returns the table-module and spawns it if it isnt already spawned.
-  def tables
-    if !@tables
-      require "#{File.dirname(__FILE__)}/drivers/#{@opts[:type]}/knjdb_#{@opts[:type]}_tables" if (!@opts.key?(:require) or @opts[:require])
-      @tables = Kernel.const_get("KnjDB_#{@opts[:type]}".to_sym).const_get(:Tables).new(
-        :db => self
-      )
-    end
-    
-    return @tables
-  end
-  
-  #Returns the columns-module and spawns it if it isnt already spawned.
-  def cols
-    if !@cols
-      require "#{File.dirname(__FILE__)}/drivers/#{@opts[:type]}/knjdb_#{@opts[:type]}_columns" if (!@opts.key?(:require) or @opts[:require])
-      @cols = Kernel.const_get("KnjDB_#{@opts[:type]}".to_sym).const_get(:Columns).new(
-        :db => self
-      )
-    end
-    
-    return @cols
-  end
-  
-  #Returns the index-module and spawns it if it isnt already spawned.
-  def indexes
-    if !@indexes
-      require "#{File.dirname(__FILE__)}/drivers/#{@opts[:type]}/knjdb_#{@opts[:type]}_indexes" if (!@opts.key?(:require) or @opts[:require])
-      @indexes = Kernel.const_get("KnjDB_#{@opts[:type]}".to_sym).const_get(:Indexes).new(
-        :db => self
-      )
-    end
-    
-    return @indexes
-  end
-  
-  #Returns the SQLSpec-module and spawns it if it isnt already spawned.
-  def sqlspecs
-    if !@sqlspecs
-      require "#{File.dirname(__FILE__)}/drivers/#{@opts[:type]}/knjdb_#{@opts[:type]}_sqlspecs" if (!@opts.key?(:require) or @opts[:require])
-      @sqlspecs = Kernel.const_get("KnjDB_#{@opts[:type]}".to_sym).const_get(:Sqlspecs).new(
-        :db => self
-      )
-    end
-    
-    return @sqlspecs
-  end
-  
-  #Beings a transaction and commits when the block ends.
-  #
-  #===Examples
-  # db.transaction do |db|
-  #   db.insert(:users, {:name => "John"})
-  #   db.insert(:users, {:name => "Kasper"})
-  # end
-  def transaction(&block)
-    self.conn_exec do |driver|
-      driver.transaction(&block)
-    end
-  end
-  
-  #Optimizes all tables in the database.
-  def optimize(args = nil)
-    STDOUT.puts "Beginning optimization of database." if @debug or (args and args[:debug])
-    self.tables.list do |table|
-      STDOUT.puts "Optimizing table: '#{table.name}'." if @debug or (args and args[:debug])
-      table.optimize
-    end
-    
-    return nil
-  end
-  
-  #Proxies the method to the driver.
-  #
-  #===Examples
-  # db.method_on_driver
-  def method_missing(method_name, *args)
-    self.conn_exec do |driver|
-      if driver.respond_to?(method_name.to_sym)
-        return driver.send(method_name, *args)
-      end
-    end
-    
-    raise "Method not found: #{method_name}"
-  end
-end