knjrbfw 0.0.110 → 0.0.111

data/lib/knj/knjdb/drivers/sqlite3/knjdb_sqlite3.rb

@@ -1,184 +0,0 @@
-#This class handels SQLite3-specific behaviour.
-class KnjDB_sqlite3
-  attr_reader :knjdb, :conn, :sep_table, :sep_col, :sep_val, :symbolize
-  attr_accessor :tables, :cols, :indexes
-  
-  #Constructor. This should not be called manually.
-  def initialize(knjdb_ob)
-    @sep_table = "`"
-    @sep_col = "`"
-    @sep_val = "'"
-    
-    @knjdb = knjdb_ob
-    @path = @knjdb.opts[:path] if @knjdb.opts[:path]
-    @path = @knjdb.opts["path"] if @knjdb.opts["path"]
-    @symbolize = true if !@knjdb.opts.key?(:return_keys) or @knjdb.opts[:return_keys] == "symbols"
-    
-    @knjdb.opts[:subtype] = "java" if !@knjdb.opts.key?(:subtype) and RUBY_ENGINE == "jruby"
-    raise "No path was given." if !@path
-    
-    if @knjdb.opts[:subtype] == "java"
-      if @knjdb.opts[:sqlite_driver]
-        require @knjdb.opts[:sqlite_driver]
-      else
-        require "#{File.dirname(__FILE__)}/../../../jruby/sqlitejdbc-v056.jar"
-      end
-      
-      require "java"
-      import "org.sqlite.JDBC"
-      @conn = java.sql.DriverManager::getConnection("jdbc:sqlite:#{@knjdb.opts[:path]}")
-      @stat = @conn.createStatement
-    elsif @knjdb.opts[:subtype] == "rhodes"
-      @conn = SQLite3::Database.new(@path, @path)
-    else
-      @conn = SQLite3::Database.open(@path)
-      @conn.results_as_hash = true
-      @conn.type_translation = false
-    end
-  end
-  
-  #Executes a query against the driver.
-  def query(string)
-    begin
-      if @knjdb.opts[:subtype] == "rhodes"
-        return KnjDB_sqlite3_result.new(self, @conn.execute(string, string))
-      elsif @knjdb.opts[:subtype] == "java"
-        begin
-          return KnjDB_sqlite3_result_java.new(self, @stat.executeQuery(string))
-        rescue java.sql.SQLException => e
-          if e.message.to_s.index("query does not return ResultSet") != nil
-            return KnjDB_sqlite3_result_java.new(self, nil)
-          else
-            raise e
-          end
-        end
-      else
-        return KnjDB_sqlite3_result.new(self, @conn.execute(string))
-      end
-    rescue => e
-      #Add SQL to the error message.
-      raise e.class, "#{e.message} (SQL: #{string})"
-    end
-  end
-  
-  #SQLite3 driver doesnt support unbuffered queries??
-  alias query_ubuf query
-  
-  #Escapes a string to be safe to used in a query.
-  def escape(string)
-    #This code is taken directly from the documentation so we dont have to rely on the SQLite3::Database class. This way it can also be used with JRuby and IronRuby...
-    #http://sqlite-ruby.rubyforge.org/classes/SQLite/Database.html
-    return string.to_s.gsub(/'/, "''")
-  end
-  
-  #Escapes a string to be used as a column.
-  def esc_col(string)
-    string = string.to_s
-    raise "Invalid column-string: #{string}" if string.index(@sep_col) != nil
-    return string
-  end
-  
-  alias :esc_table :esc_col
-  alias :esc :escape
-  
-  #Returns the last inserted ID.
-  def lastID
-    return @conn.last_insert_row_id if @conn.respond_to?(:last_insert_row_id)
-    return self.query("SELECT last_insert_rowid() AS id").fetch[:id].to_i
-  end
-  
-  #Closes the connection to the database.
-  def close
-    @conn.close
-  end
-  
-  #Starts a transaction, yields the database and commits.
-  def transaction
-    @conn.transaction do
-      yield(@knjdb)
-    end
-  end
-end
-
-#This class handels results when running in JRuby.
-class KnjDB_sqlite3_result_java
-  def initialize(driver, rs)
-    @index = 0
-    retkeys = driver.knjdb.opts[:return_keys]
-    
-    if rs
-      metadata = rs.getMetaData
-      columns_count = metadata.getColumnCount
-      
-      @rows = []
-      while rs.next
-        row_data = {}
-        for i in (1..columns_count)
-          col_name = metadata.getColumnName(i)
-          col_name = col_name.to_s.to_sym if retkeys == "symbols"
-          row_data[col_name] = rs.getString(i)
-        end
-        
-        @rows << row_data
-      end
-    end
-  end
-  
-  #Returns a single result.
-  def fetch
-    return false if !@rows
-    ret = @rows[@index]
-    return false if !ret
-    @index += 1
-    return ret
-  end
-  
-  #Loops over every result and yields them.
-  def each
-    while data = self.fetch
-      yield(data)
-    end
-  end
-end
-
-#This class handels the result when running MRI (or others).
-class KnjDB_sqlite3_result
-  #Constructor. This should not be called manually.
-  def initialize(driver, result_array)
-    @result_array = result_array
-    @index = 0
-    
-    if driver.knjdb.opts[:return_keys] == "symbols"
-      @symbols = true
-    else
-      @symbols = false
-    end
-  end
-  
-  #Returns a single result.
-  def fetch
-    result_hash = @result_array[@index]
-    return false if !result_hash
-    @index += 1
-    
-    ret = {}
-    result_hash.each do |key, val|
-      if (Float(key) rescue false)
-        #do nothing.
-      elsif @symbols and !key.is_a?(Symbol)
-        ret[key.to_sym] = val
-      else
-        ret[key] = val
-      end
-    end
-    
-    return ret
-  end
-  
-  #Loops over every result yielding them.
-  def each
-    while data = self.fetch
-      yield(data)
-    end
-  end
-end

data/lib/knj/knjdb/drivers/sqlite3/knjdb_sqlite3_columns.rb

@@ -1,177 +0,0 @@
-#This class handels the SQLite3-specific behaviour for columns.
-class KnjDB_sqlite3::Columns
-  attr_reader :db
-  
-  #Constructor. This should not be called manually.
-  def initialize(args)
-    @args = args
-  end
-  
-  #Returns SQL for a knjdb-compatible hash.
-  def data_sql(data)
-    raise "No type given." if !data["type"]
-    type = data["type"].to_s
-    
-    if type == "enum"
-      type = "varchar"
-      data.delete("maxlength")
-    end
-    
-    data["maxlength"] = 255 if type == "varchar" and !data.key?("maxlength")
-    data["maxlength"] = 11 if type == "int" and !data.key?("maxlength") and !data["autoincr"] and !data["primarykey"]
-    type = "integer" if @args[:db].int_types.index(type) and (data["autoincr"] or data["primarykey"])
-    
-    sql = "`#{data["name"]}` #{type}"
-    sql << "(#{data["maxlength"]})" if data["maxlength"] and !data["autoincr"]
-    sql << " PRIMARY KEY" if data["primarykey"]
-    sql << " AUTOINCREMENT" if data["autoincr"]
-    
-    if !data["null"] and data.key?("null")
-      sql << " NOT NULL"
-      
-      if !data.key?("default") or !data["default"]
-        data["default"] = 0 if type == "int"
-      end
-    end
-    
-    if data.key?("default_func")
-      sql << " DEFAULT #{data["default_func"]}"
-    elsif data.key?("default") and data["default"] != false
-      sql << " DEFAULT '#{@args[:db].escape(data["default"])}'"
-    end
-    
-    return sql
-  end
-end
-
-#This class handels all the SQLite3-columns.
-class KnjDB_sqlite3::Columns::Column
-  attr_reader :args
-  
-  #Constructor. This should not be called manually.
-  def initialize(args)
-    @args = args
-    @db = @args[:db]
-  end
-  
-  #Returns the name of the column.
-  def name
-    return @args[:data][:name]
-  end
-  
-  #Returns the columns table-object.
-  def table
-    return @db.tables[@args[:table_name]]
-  end
-  
-  #Returns the data of the column as a hash in knjdb-format.
-  def data
-    return {
-      "type" => self.type,
-      "name" => self.name,
-      "null" => self.null?,
-      "maxlength" => self.maxlength,
-      "default" => self.default,
-      "primarykey" => self.primarykey?,
-      "autoincr" => self.autoincr?
-    }
-  end
-  
-  #Returns the type of the column.
-  def type
-    if !@type
-      if match = @args[:data][:type].match(/^([A-z]+)$/)
-        @maxlength = false
-        type = match[0].to_sym
-      elsif match = @args[:data][:type].match(/^decimal\((\d+),(\d+)\)$/)
-        @maxlength = "#{match[1]},#{match[2]}"
-        type = :decimal
-      elsif match = @args[:data][:type].match(/^enum\((.+)\)$/)
-        @maxlength = match[1]
-        type = :enum
-      elsif match = @args[:data][:type].match(/^(.+)\((\d+)\)$/)
-        @maxlength = match[2]
-        type = match[1].to_sym
-      elsif @args[:data].key?(:type) and @args[:data][:type].to_s == ""
-        #A type can actually be empty in SQLite... Wtf?
-        return @args[:data][:type]
-      end
-      
-      if type == :integer
-        @type = :int
-      else
-        @type = type
-      end
-      
-      raise "Still not type? (#{@args[:data]})" if @type.to_s.strip.length <= 0
-    end
-    
-    return @type
-  end
-  
-  #Returns true if the column allows null. Otherwise false.
-  def null?
-    return false if @args[:data][:notnull].to_i == 1
-    return true
-  end
-  
-  #Returns the maxlength of the column.
-  def maxlength
-    self.type if !@maxlength
-    return @maxlength if @maxlength
-    return false
-  end
-  
-  #Returns the default value of the column.
-  def default
-    def_val = @args[:data][:dflt_value]
-    if def_val.to_s.slice(0..0) == "'"
-      def_val = def_val.to_s.slice(0)
-    end
-    
-    if def_val.to_s.slice(-1..-1) == "'"
-      def_val = def_val.to_s.slice(0, def_val.length - 1)
-    end
-    
-    return false if @args[:data][:dflt_value].to_s.length == 0
-    return def_val
-  end
-  
-  #Returns true if the column is the primary key.
-  def primarykey?
-    return false if @args[:data][:pk].to_i == 0
-    return true
-  end
-  
-  #Returns true if the column is auto-increasing.
-  def autoincr?
-    return true if @args[:data][:pk].to_i == 1 and @args[:data][:type].to_s == "integer"
-    return false
-  end
-  
-  #Drops the column from the table.
-  def drop
-    self.table.copy("drops" => self.name)
-  end
-  
-  #Changes data on the column. Like the name, type, maxlength or whatever.
-  def change(data)
-    newdata = data.clone
-    
-    newdata["name"] = self.name if !newdata.key?("name")
-    newdata["type"] = self.type if !newdata.key?("type")
-    newdata["maxlength"] = self.maxlength if !newdata.key?("maxlength") and self.maxlength
-    newdata["null"] = self.null? if !newdata.key?("null")
-    newdata["default"] = self.default if !newdata.key?("default")
-    newdata["primarykey"] = self.primarykey? if !newdata.key?("primarykey")
-    
-    @type = nil
-    @maxlength = nil
-    
-    new_table = self.table.copy(
-      "alter_columns" => {
-        self.name.to_s => newdata
-      }
-    )
-  end
-end

data/lib/knj/knjdb/drivers/sqlite3/knjdb_sqlite3_indexes.rb

@@ -1,29 +0,0 @@
-class KnjDB_sqlite3::Indexes
-  def initialize(args)
-    @args = args
-  end
-end
-
-class KnjDB_sqlite3::Indexes::Index
-  attr_reader :columns
-  
-  def initialize(args)
-    @args = args
-    @columns = []
-  end
-  
-  def name
-    return @args[:data][:name]
-  end
-  
-  def drop
-    @args[:db].query("DROP INDEX `#{self.name}`")
-  end
-  
-  def data
-    return {
-      "name" => name,
-      "columns" => @columns
-    }
-  end
-end

data/lib/knj/knjdb/drivers/sqlite3/knjdb_sqlite3_sqlspecs.rb

@@ -1,5 +0,0 @@
-class KnjDB_sqlite3::Sqlspecs < Knj::Db::Sqlspecs
-  def strftime(val, col_str)
-    return "STRFTIME('#{val}', SUBSTR(#{col_str}, 0, 20))"
-  end
-end

data/lib/knj/knjdb/drivers/sqlite3/knjdb_sqlite3_tables.rb

@@ -1,449 +0,0 @@
-class KnjDB_sqlite3::Tables
-  attr_reader :db, :driver
-  
-  def initialize(args)
-    @args = args
-    @db = @args[:db]
-    
-    @list_mutex = Mutex.new
-    @list = Wref_map.new
-  end
-  
-  def [](table_name)
-    table_name = table_name.to_s
-    
-    begin
-      ret = @list[table_name]
-      return ret
-    rescue Wref::Recycled
-      #ignore.
-    end
-    
-    self.list do |table_obj|
-      return table_obj if table_obj.name.to_s == table_name.to_s
-    end
-    
-    raise Errno::ENOENT, "Table was not found: #{table_name}."
-  end
-  
-  def list
-    ret = {} unless block_given?
-    
-    @list_mutex.synchronize do
-      q_tables = @db.select("sqlite_master", {"type" => "table"}, {"orderby" => "name"}) do |d_tables|
-        next if d_tables[:name] == "sqlite_sequence"
-        
-        obj = @list.get!(d_tables[:name])
-        
-        if !obj
-          obj = KnjDB_sqlite3::Tables::Table.new(
-            :db => @db,
-            :data => d_tables
-          )
-          @list[d_tables[:name]] = obj
-        end
-        
-        if block_given?
-          yield(obj)
-        else
-          ret[d_tables[:name]] = obj
-        end
-      end
-    end
-    
-    if block_given?
-      return nil
-    else
-      return ret
-    end
-  end
-  
-  def create(name, data, args = nil)
-    sql = "CREATE TABLE `#{name}` ("
-    
-    first = true
-    data["columns"].each do |col_data|
-      sql << ", " if !first
-      first = false if first
-      sql << @db.cols.data_sql(col_data)
-    end
-    
-    sql << ")"
-    
-    if args and args[:return_sql]
-      ret = [sql]
-    else
-      @db.query(sql)
-    end
-    
-    if data.key?("indexes") and data["indexes"]
-      table_obj = self[name]
-      
-      if args and args[:return_sql]
-        ret += table_obj.create_indexes(data["indexes"], :return_sql => true)
-      else
-        table_obj.create_indexes(data["indexes"])
-      end
-    end
-    
-    if args and args[:return_sql]
-      return ret
-    else
-      return nil
-    end
-  end
-end
-
-class KnjDB_sqlite3::Tables::Table
-  def initialize(args)
-    @db = args[:db]
-    @data = args[:data]
-    
-    @list = Wref_map.new
-    @indexes_list = Wref_map.new
-  end
-  
-  def name
-    return @data[:name]
-  end
-  
-  def type
-    return @data[:type]
-  end
-  
-  def maxlength
-    return @data[:maxlength]
-  end
-  
-  def reload
-    @data = @db.select("sqlite_master", {"type" => "table", "name" => self.name}, {"orderby" => "name"}).fetch
-  end
-  
-  def rows_count
-    data = @db.q("SELECT COUNT(*) AS count FROM `#{self.name}`").fetch
-    return data[:count].to_i
-  end
-  
-  #Drops the table from the database.
-  def drop
-    raise "Cant drop native table: '#{self.name}'." if self.native?
-    @db.query("DROP TABLE `#{self.name}`")
-  end
-  
-  #Returns true if the table is safe to drop.
-  def native?
-    return true if self.name.to_s == "sqlite_sequence"
-    return false
-  end
-  
-  def optimize
-    raise "stub!"
-  end
-  
-  def rename(newname)
-    self.clone(newname)
-    self.drop
-  end
-  
-  def truncate
-    @db.query("DELETE FROM `#{self.name}` WHERE 1=1")
-    return nil
-  end
-  
-  def table
-    return @db.tables[@table_name]
-  end
-  
-  def column(name)
-    list = self.columns
-    return list[name] if list[name]
-    raise Errno::ENOENT.new("Column not found: #{name}.")
-  end
-  
-  def columns
-    @db.cols
-    ret = {}
-    
-    @db.q("PRAGMA table_info(`#{@db.esc_table(self.name)}`)") do |d_cols|
-      obj = @list.get!(d_cols[:name])
-      
-      if !obj
-        obj = KnjDB_sqlite3::Columns::Column.new(
-          :table_name => self.name,
-          :db => @db,
-          :data => d_cols
-        )
-        @list[d_cols[:name]] = obj
-      end
-      
-      if block_given?
-        yield(obj)
-      else
-        ret[d_cols[:name]] = obj
-      end
-    end
-    
-    if block_given?
-      return nil
-    else
-      return ret
-    end
-  end
-  
-  def create_columns(col_arr)
-    col_arr.each do |col_data|
-      #if col_data.key?("after")
-      #  self.create_column_programmatic(col_data)
-      #else
-        @db.query("ALTER TABLE `#{self.name}` ADD COLUMN #{@db.cols.data_sql(col_data)};")
-      #end
-    end
-  end
-  
-  def create_column_programmatic(col_data)
-    temp_name = "temptable_#{Time.now.to_f.to_s.hash}"
-    cloned_tabled = self.clone(temp_name)
-    cols_cur = self.columns
-    @db.query("DROP TABLE `#{self.name}`")
-    
-    sql = "CREATE TABLE `#{self.name}` ("
-    first = true
-    cols_cur.each do |name, col|
-      sql << ", " if !first
-      first = false if first
-      sql << @db.cols.data_sql(col.data)
-      
-      if col_data["after"] and col_data["after"] == name
-        sql << ", #{@db.cols.data_sql(col_data)}"
-      end
-    end
-    sql << ");"
-    @db.query(sql)
-    
-    sql = "INSERT INTO `#{self.name}` SELECT "
-    first = true
-    cols_cur.each do |name, col|
-      sql << ", " if !first
-      first = false if first
-      
-      sql << "`#{name}`"
-      
-      if col_data["after"] and col_data["after"] == name
-        sql << ", ''"
-      end
-    end
-    sql << " FROM `#{temp_name}`"
-    @db.query(sql)
-    @db.query("DROP TABLE `#{temp_name}`")
-  end
-  
-  def clone(newname)
-    raise "Invalid name." if newname.to_s.strip.length <= 0
-    cols_cur = self.columns
-    
-    sql = "CREATE TABLE `#{newname}` ("
-    first = true
-    cols_cur.each do |name, col|
-      sql << ", " if !first
-      first = false if first
-      sql << @db.cols.data_sql(col.data)
-    end
-    
-    sql << ");"
-    @db.query(sql)
-    
-    sql = "INSERT INTO `#{newname}` SELECT * FROM `#{self.name}`"
-    @db.query(sql)
-    return @db.tables[newname]
-  end
-  
-  def copy(args = {})
-    temp_name = "temptable_#{Time.now.to_f.to_s.hash}"
-    cloned_tabled = self.clone(temp_name)
-    cols_cur = self.columns
-    @db.query("DROP TABLE `#{self.name}`")
-    
-    sql = "CREATE TABLE `#{self.name}` ("
-    first = true
-    cols_cur.each do |name, col|
-      next if args["drops"] and args["drops"].index(name) != nil
-      
-      sql << ", " if !first
-      first = false if first
-      
-      if args.key?("alter_columns") and args["alter_columns"][name.to_s]
-        sql << @db.cols.data_sql(args["alter_columns"][name.to_s])
-      else
-        sql << @db.cols.data_sql(col.data)
-      end
-      
-      if args["new"]
-        args["new"].each do |col_data|
-          if col_data["after"] and col_data["after"] == name
-            sql << ", #{@db.cols.data_sql(col_data)}"
-          end
-        end
-      end
-    end
-    sql << ");"
-    @db.query(sql)
-    
-    sql = "INSERT INTO `#{self.name}` SELECT "
-    first = true
-    cols_cur.each do |name, col|
-      next if args["drops"] and args["drops"].index(name) != nil
-      
-      sql << ", " if !first
-      first = false if first
-      
-      sql << "`#{name}`"
-      
-      if args["news"]
-        args["news"].each do |col_data|
-          if col_data["after"] and col_data["after"] == name
-            sql << ", ''"
-          end
-        end
-      end
-    end
-    
-    sql << " FROM `#{temp_name}`"
-    @db.query(sql)
-    @db.query("DROP TABLE `#{temp_name}`")
-  end
-  
-  def index(name)
-    name = name.to_s
-    
-    begin
-      return @indexes_list[name]
-    rescue Wref::Recycled
-      if @db.opts[:index_append_table_name]
-        tryname = "#{self.name}__#{name}"
-        
-        begin
-          return @indexes_list[tryname]
-        rescue Wref::Recycled
-          #ignore.
-        end
-      else
-        #ignore
-      end
-    end
-    
-    self.indexes do |index|
-      return index if index.name.to_s == name
-    end
-    
-    raise Errno::ENOENT.new("Index not found: #{name}.")
-  end
-  
-  def indexes
-    @db.indexes
-    ret = {} unless block_given?
-    
-    @db.q("PRAGMA index_list(`#{@db.esc_table(self.name)}`)") do |d_indexes|
-      next if d_indexes[:Key_name] == "PRIMARY"
-      
-      obj = @indexes_list.get!(d_indexes[:name])
-      
-      if !obj
-        if @db.opts[:index_append_table_name]
-          match_name = d_indexes[:name].match(/__(.+)$/)
-          
-          if match_name
-            name = match_name[1]
-          else
-            name = d_indexes[:name]
-          end
-        else
-          name = d_indexes[:name]
-        end
-        
-        obj = KnjDB_sqlite3::Indexes::Index.new(
-          :table_name => self.name,
-          :db => @db,
-          :data => d_indexes
-        )
-        obj.columns << name
-        @indexes_list[d_indexes[:name]] = obj
-      end
-      
-      if block_given?
-        yield(obj)
-      else
-        ret[d_indexes[:name]] = obj
-      end
-    end
-    
-    if block_given?
-      return nil
-    else
-      return ret
-    end
-  end
-  
-  def create_indexes(index_arr, args = nil)
-    if args and args[:return_sql]
-      ret = []
-    end
-    
-    index_arr.each do |index_data|
-      if index_data.is_a?(String)
-        index_data = {"name" => index_data, "columns" => [index_data]}
-      end
-      
-      raise "No name was given." if !index_data.key?("name") or index_data["name"].strip.length <= 0
-      raise "No columns was given on index #{index_data["name"]}." if index_data["columns"].empty?
-      
-      name = index_data["name"]
-      name = "#{self.name}__#{name}" if @db.opts[:index_append_table_name]
-      
-      sql = "CREATE INDEX '#{@db.esc_col(name)}' ON `#{@db.esc_table(self.name)}` ("
-      
-      first = true
-      index_data["columns"].each do |col_name|
-        sql << ", " if !first
-        first = false if first
-        
-        sql << "`#{@db.esc_col(col_name)}`"
-      end
-      
-      sql << ")"
-      
-      if args and args[:return_sql]
-        ret << sql
-      else
-        @db.query(sql)
-      end
-    end
-    
-    if args and args[:return_sql]
-      return ret
-    else
-      return nil
-    end
-  end
-  
-  def data
-    ret = {
-      "name" => name,
-      "columns" => [],
-      "indexes" => []
-    }
-    
-    columns.each do |name, column|
-      ret["columns"] << column.data
-    end
-    
-    indexes.each do |name, index|
-      ret["indexes"] << index.data if name != "PRIMARY"
-    end
-    
-    return ret
-  end
-  
-  def insert(data)
-    @db.insert(self.name, data)
-  end
-end