baza 0.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,18 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+gem "datet"
+gem "wref"
+gem "knjrbfw"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.8.0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", "~> 1.8.4"
+  gem "sqlite3"
+end

data/Gemfile.lock

@@ -0,0 +1,55 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    datet (0.0.25)
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    http2 (0.0.13)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.7)
+    knjrbfw (0.0.104)
+      datet
+      http2
+      php4r
+      ruby_process
+      tsafe
+      wref
+    php4r (0.0.4)
+      datet
+      http2
+      string-strtr
+    rake (10.0.4)
+    rdoc (3.12.2)
+      json (~> 1.4)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    ruby_process (0.0.8)
+      tsafe
+      wref
+    sqlite3 (1.3.7)
+    string-strtr (0.0.3)
+    tsafe (0.0.11)
+    wref (0.0.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.0.0)
+  datet
+  jeweler (~> 1.8.4)
+  knjrbfw
+  rdoc (~> 3.12)
+  rspec (~> 2.8.0)
+  sqlite3
+  wref

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Kasper Johansen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,19 @@
+= baza
+
+Description goes here.
+
+== Contributing to baza
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2013 Kasper Johansen. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "baza"
+  gem.homepage = "http://github.com/kaspernj/baza"
+  gem.license = "MIT"
+  gem.summary = %Q{A database abstraction layer, model framework and database framework.}
+  gem.description = %Q{A database abstraction layer, model framework and database framework.}
+  gem.email = "kj@gfish.com"
+  gem.authors = ["Kasper Johansen"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "baza #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/include/db.rb

@@ -0,0 +1,784 @@
+require "knjrbfw"
+Knj.gem_require([:wref, :datet])
+
+#A wrapper of several possible database-types.
+#
+#===Examples
+# db = Baza::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 = Baza::Db.new(:type => "sqlite3", :path => "some_db.sqlite3")
+#
+# db.q("SELECT * FROM users") do |data|
+#   print data[:name]
+# end
+class Baza::Db
+  attr_reader :sep_col, :sep_table, :sep_val, :opts, :conn, :conns, :int_types
+  
+  def initialize(opts)
+    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
+    
+    @type_cc = "#{@opts[:type].to_s.slice(0, 1).upcase}#{@opts[:type].to_s.slice(1, @opts[:type].to_s.length)}"
+    self.connect
+  end
+  
+  #Actually connects to the database. This is useually done automatically.
+  def connect
+    if @opts[:threadsafe]
+      require "#{$knjpath}threadhandler"
+      @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]
+    rpath = "#{File.dirname(__FILE__)}/#{"drivers/#{@opts[:type]}/#{@opts[:type]}.rb"}"
+    require rpath if (!@opts.key?(:require) or @opts[:require]) and File.exists?(rpath)
+    return Baza::Driver.const_get(@type_cc).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 = Baza::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 Baza::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, selector)
+    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 = Baza::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)
+    Baza::QueryBuffer.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]}/#{@opts[:type]}_tables" if (!@opts.key?(:require) or @opts[:require])
+      @tables = Baza::Driver.const_get(@type_cc).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]}/#{@opts[:type]}_columns" if (!@opts.key?(:require) or @opts[:require])
+      @cols = Baza::Driver.const_get(@type_cc).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]}/#{@opts[:type]}_indexes" if (!@opts.key?(:require) or @opts[:require])
+      @indexes = Baza::Driver.const_get(@type_cc).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]}/#{@opts[:type]}_sqlspecs" if (!@opts.key?(:require) or @opts[:require])
+      @sqlspecs = Baza::Driver.const_get(@type_cc).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
+
+#Subclass that contains all the drivers as further subclasses.
+class Baza::Driver
+  
+end