knjrbfw 0.0.110 → 0.0.111

data/lib/knj/knjdb/drivers/mysql/knjdb_mysql_columns.rb

@@ -1,155 +0,0 @@
-#This class handels various MySQL-column-specific operations.
-class KnjDB_mysql::Columns
-  #Constructor. Should not be called manually.
-  def initialize(args)
-    @args = args
-  end
-  
-  #Returns the SQL for this column.
-  def data_sql(data)
-    raise "No type given." if !data["type"]
-    
-    data["maxlength"] = 255 if data["type"] == "varchar" and !data.key?("maxlength")
-    
-    sql = "`#{data["name"]}` #{data["type"]}"
-    sql << "(#{data["maxlength"]})" if data["maxlength"]
-    sql << " PRIMARY KEY" if data["primarykey"]
-    sql << " AUTO_INCREMENT" if data["autoincr"]
-    sql << " NOT NULL" if !data["null"]
-    
-    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
-    
-    sql << " COMMENT '#{@args[:db].escape(data["comment"])}'" if data.key?("comment")
-    sql << " AFTER `#{@args[:db].esc_col(data["after"])}`" if data["after"] and !data["first"]
-    sql << " FIRST" if data["first"]
-    sql << " STORAGE #{data["storage"].to_s.upcase}" if data["storage"]
-    
-    return sql
-  end
-end
-
-#This class handels every MySQL-column, that can be returned from a table-object.
-class KnjDB_mysql::Columns::Column
-  attr_reader :args
-  
-  #Constructor. Should not be called manually.
-  def initialize(args)
-    @args = args
-  end
-  
-  #Used to validate in Knj::Wrap_map.
-  def __object_unique_id__
-    return @args[:data][:Field]
-  end
-  
-  #Returns the name of the column.
-  def name
-    return @args[:data][:Field]
-  end
-  
-  #Returns the table-object that this column belongs to.
-  def table
-    return @args[:db].tables[@args[:table_name]]
-  end
-  
-  #Returns all data of the column in the 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 (integer, varchar etc.).
-  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].to_i
-        @type = match[1].to_sym
-      end
-      
-      raise "Still not type from: '#{@args[:data][:Type]}'." if @type.to_s.strip.length <= 0
-    end
-    
-    return @type
-  end
-  
-  #Return true if the columns allows null. Otherwise false.
-  def null?
-    return false if @args[:data][:Null] == "NO"
-    return true
-  end
-  
-  #Returns the maxlength.
-  def maxlength
-    self.type if !@maxlength
-    return @maxlength if @maxlength
-    return false
-  end
-  
-  #Returns the default value for the column.
-  def default
-    return false if (self.type == "datetime" or self.type == "date") and @args[:data][:Default].to_s.strip.length <= 0
-    return false if (self.type == "int" or self.type == "bigint") and @args[:data][:Default].to_s.strip.length <= 0
-    return false if !@args[:data][:Default]
-    return @args[:data][:Default]
-  end
-  
-  #Returns true if the column is the primary key. Otherwise false.
-  def primarykey?
-    return true if @args[:data][:Key] == "PRI"
-    return false
-  end
-  
-  #Returns true if the column is auto-increasing. Otherwise false.
-  def autoincr?
-    return true if @args[:data][:Extra].index("auto_increment") != nil
-    return false
-  end
-  
-  #Returns the comment for the column.
-  def comment
-    return @args[:data][:Comment]
-  end
-  
-  #Drops the column from the table.
-  def drop
-    @args[:db].query("ALTER TABLE `#{@args[:table_name]}` DROP COLUMN `#{self.name}`")
-    return nil
-  end
-  
-  #Changes the column properties by the given hash.
-  def change(data)
-    col_escaped = "`#{@args[:db].esc_col(self.name)}`"
-    table_escape = "`#{@args[:db].esc_table(self.table.name)}`"
-    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") and self.default
-    newdata.delete("primarykey") if newdata.key?("primarykey")
-    
-    type_s = newdata["type"].to_s
-    @args[:db].query("ALTER TABLE #{table_escape} CHANGE #{col_escaped} #{@args[:db].cols.data_sql(newdata)}")
-  end
-end

data/lib/knj/knjdb/drivers/mysql/knjdb_mysql_indexes.rb

@@ -1,69 +0,0 @@
-class KnjDB_mysql::Indexes
-  def initialize(args)
-    @args = args
-  end
-end
-
-class KnjDB_mysql::Indexes::Index
-  attr_reader :columns
-  
-  def initialize(args)
-    @args = args
-    @columns = []
-  end
-  
-  #Used to validate in Knj::Wrap_map.
-  def __object_unique_id__
-    return @args[:data][:Key_name]
-  end
-  
-  def name
-    return @args[:data][:Key_name]
-  end
-  
-  def table
-    return @args[:db].tables[@args[:table_name]]
-  end
-  
-  def drop
-    sql = "DROP INDEX `#{self.name}` ON `#{self.table.name}`"
-    
-    begin
-      @args[:db].query(sql)
-    rescue => e
-      #The index has already been dropped - ignore.
-      if e.message.index("check that column/key exists") != nil
-        #ignore.
-      else
-        raise e
-      end
-    end
-  end
-  
-  def data
-    return {
-      "name" => name,
-      "columns" => @columns
-    }
-  end
-  
-  #Returns true if the index is a unique-index.
-  def unique?
-    if @args[:data][:Index_type] == "UNIQUE"
-      return true
-    else
-      return false
-    end
-  end
-  
-  #Returns true if the index is a primary-index.
-  def primary?
-		return true if @args[:data][:Index_type] == "BTREE"
-		return false
-  end
-  
-  #Inspect crashes if this is not present? - knj.
-  def to_s
-    return "#<#{self.class.name}>"
-  end
-end

data/lib/knj/knjdb/drivers/mysql/knjdb_mysql_sqlspecs.rb

@@ -1,5 +0,0 @@
-class KnjDB_mysql::Sqlspecs < Knj::Db::Sqlspecs
-  def strftime(val, colstr)
-    return "DATE_FORMAT(#{colstr}, '#{val}')"
-  end
-end

data/lib/knj/knjdb/drivers/mysql/knjdb_mysql_tables.rb

@@ -1,443 +0,0 @@
-require "monitor"
-
-#This class handels various MySQL-table-specific behaviour.
-class KnjDB_mysql::Tables
-  attr_reader :db, :list
-  
-  #Constructor. This should not be called manually.
-  def initialize(args)
-    @args = args
-    @db = @args[:db]
-    @subtype = @db.opts[:subtype]
-    @list_mutex = Monitor.new
-    @list = Wref_map.new
-    @list_should_be_reloaded = true
-  end
-  
-  #Cleans the wref-map.
-  def clean
-    @list.clean
-  end
-  
-  #Returns a table by the given table-name.
-  def [](table_name)
-    table_name = table_name.to_s
-    
-    begin
-      return @list[table_name]
-    rescue Wref::Recycled
-      #ignore.
-    end
-    
-    self.list(:name => table_name) do |table_obj|
-      return table_obj if table_obj.name == table_name
-    end
-    
-    raise Errno::ENOENT, "Table was not found: #{table_name}."
-  end
-  
-  #Yields the tables of the current database.
-  def list(args = {})
-    ret = {} unless block_given?
-    
-    sql = "SHOW TABLE STATUS"
-    sql << " WHERE `Name` = '#{@db.esc(args[:name])}'" if args[:name]
-    
-    @list_mutex.synchronize do
-      @db.q(sql) do |d_tables|
-        obj = @list.get!(d_tables[:Name])
-        
-        if !obj
-          obj = KnjDB_mysql::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
-  
-  #Creates a new table by the given name and data.
-  def create(name, data, args = nil)
-    raise "No columns was given for '#{name}'." if !data["columns"] or data["columns"].empty?
-    
-    sql = "CREATE"
-    sql << " TEMPORARY" if data["temp"]
-    sql << " TABLE `#{name}` ("
-    
-    first = true
-    data["columns"].each do |col_data|
-      sql << ", " if !first
-      first = false if first
-      col_data.delete("after") if col_data["after"]
-      sql << @db.cols.data_sql(col_data)
-    end
-    
-    if data["indexes"] and !data["indexes"].empty?
-      sql << ", "
-      sql << KnjDB_mysql::Tables::Table.create_indexes(data["indexes"], {
-        :db => @db,
-        :return_sql => true,
-        :create => false,
-        :on_table => false,
-        :table_name => name
-      })
-    end
-    
-    sql << ")"
-    
-    return [sql] if args and args[:return_sql]
-    @db.query(sql)
-  end
-end
-
-class KnjDB_mysql::Tables::Table
-  attr_reader :list
-  
-  def initialize(args)
-    @args = args
-    @db = args[:db]
-    @data = args[:data]
-    @subtype = @db.opts[:subtype]
-    @list = Wref_map.new
-    @indexes_list = Wref_map.new
-    
-    raise "Could not figure out name from: '#{@data}'." if @data[:Name].to_s.strip.length <= 0
-  end
-  
-  def reload
-    @data = @db.q("SHOW TABLE STATUS WHERE `Name` = '#{@db.esc(self.name)}'").fetch
-  end
-  
-  #Used to validate in Knj::Wrap_map.
-  def __object_unique_id__
-    return @data[:Name]
-  end
-  
-  def name
-    return @data[:Name]
-  end
-  
-  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 @db.q("SELECT DATABASE() AS db").fetch[:db] == "mysql"
-    return false
-  end
-  
-  def optimize
-    @db.query("OPTIMIZE TABLE `#{self.name}`")
-    return self
-  end
-  
-  def rows_count
-    return @data[:Rows].to_i
-  end
-  
-  def column(name)
-    name = name.to_s
-    
-    if col = @list.get!(name)
-      return @list[name]
-    end
-    
-    self.columns(:name => name) do |col|
-      return col if col.name == name
-    end
-    
-    raise Errno::ENOENT, "Column not found: '#{name}'."
-  end
-  
-  def columns(args = nil)
-    @db.cols
-    ret = {}
-    sql = "SHOW FULL COLUMNS FROM `#{self.name}`"
-    sql << " WHERE `Field` = '#{@db.esc(args[:name])}'" if args and args.key?(:name)
-    
-    @db.q(sql) do |d_cols|
-      obj = @list.get!(d_cols[:Field].to_s)
-      
-      if !obj
-        obj = KnjDB_mysql::Columns::Column.new(
-          :table_name => self.name,
-          :db => @db,
-          :data => d_cols
-        )
-        @list[d_cols[:Field].to_s] = obj
-      end
-      
-      if block_given?
-        yield(obj)
-      else
-        ret[d_cols[:Field].to_s] = obj
-      end
-    end
-    
-    if block_given?
-      return nil
-    else
-      return ret
-    end
-  end
-  
-  def indexes(args = nil)
-    @db.indexes
-    ret = {}
-    
-    sql = "SHOW INDEX FROM `#{self.name}`"
-    sql << " WHERE `Key_name` = '#{@db.esc(args[:name])}'" if args and args.key?(:name)
-    
-    @db.q(sql) do |d_indexes|
-      next if d_indexes[:Key_name] == "PRIMARY"
-      
-      obj = @indexes_list.get!(d_indexes[:Key_name].to_s)
-      
-      if !obj
-        obj = KnjDB_mysql::Indexes::Index.new(
-          :table_name => self.name,
-          :db => @db,
-          :data => d_indexes
-        )
-        obj.columns << d_indexes[:Column_name]
-        @indexes_list[d_indexes[:Key_name].to_s] = obj
-      end
-      
-      if block_given?
-        yield(obj)
-      else
-        ret[d_indexes[:Key_name].to_s] = obj
-      end
-    end
-    
-    if block_given?
-      return nil
-    else
-      return ret
-    end
-  end
-  
-  def index(name)
-    name = name.to_s
-    
-    if index = @indexes_list.get!(name)
-      return index
-    end
-    
-    self.indexes(:name => name) do |index|
-      return index if index.name.to_s == name
-    end
-    
-    raise Errno::ENOENT, "Index not found: #{name}."
-  end
-  
-  def create_columns(col_arr)
-    col_arr.each do |col_data|
-      sql = "ALTER TABLE `#{self.name}` ADD COLUMN #{@db.cols.data_sql(col_data)};"
-      @db.query(sql)
-    end
-  end
-  
-  def create_indexes(index_arr, args = {})
-    return KnjDB_mysql::Tables::Table.create_indexes(index_arr, args.merge(:table_name => self.name, :db => @db))
-  end
-  
-  def self.create_indexes(index_arr, args = {})
-    db = args[:db]
-    
-    if args[:return_sql]
-      sql = ""
-      first = true
-    end
-    
-    index_arr.each do |index_data|
-      if !args[:return_sql]
-        sql = ""
-      end
-      
-      if args[:create] or !args.key?(:create)
-        sql << "CREATE"
-      end
-      
-      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"] or index_data["columns"].empty?
-      
-      if args[:return_sql]
-        if first
-          first = false
-        else
-          sql << ", "
-        end
-      end
-      
-      sql << " UNIQUE" if index_data["unique"]
-      sql << " INDEX `#{db.esc_col(index_data["name"])}`"
-      
-      if args[:on_table] or !args.key?(:on_table)
-        sql << " ON `#{db.esc_table(args[:table_name])}`"
-      end
-      
-      sql << " ("
-      
-      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[:return_sql]
-        db.query(sql)
-      end
-    end
-    
-    if args[:return_sql]
-      return sql
-    else
-      return nil
-    end
-  end
-  
-  def rename(newname)
-    oldname = self.name
-    @db.query("ALTER TABLE `#{oldname}` RENAME TO `#{newname}`")
-    @db.tables.list[newname] = self
-    @db.tables.list.delete(oldname)
-    @data[:Name] = newname
-  end
-  
-  def truncate
-    @db.query("TRUNCATE `#{self.name}`")
-    return self
-  end
-  
-  def data
-    ret = {
-      "name" => self.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
-  
-  #Returns the current engine of the table.
-  def engine
-		return @data[:Engine]
-  end
-  
-  def clone(newname, args = {})
-    raise "Invalid name." if newname.to_s.strip.empty?
-    
-    sql = "CREATE TABLE `#{@db.esc_table(newname)}` ("
-    first = true
-    pkey_found = false
-    pkeys = []
-    
-    self.columns do |col|
-      sql << ", " if !first
-      first = false if first
-      
-      col_data = col.data
-      pkey_found = true if !pkey_found and col_data["primarykey"] and args[:force_single_pkey]
-      
-      if args[:no_pkey] or (pkey_found and col_data["primarykey"] and args[:force_single_pkey])
-				col_data["primarykey"] = false
-			end
-			
-			if col_data["primarykey"]
-				pkeys << col_data["name"]
-				col_data.delete("primarykey")
-			end
-			
-			if args[:all_cols_storage]
-				col_data["storage"] = args[:all_cols_storage]
-			end
-			
-      sql << @db.cols.data_sql(col_data)
-    end
-    
-    if !pkeys.empty?
-			sql << ", PRIMARY KEY ("
-			
-			first = true
-			pkeys.each do |pkey|
-				sql << ", " if !first
-				first = false if first
-				sql << "`#{@db.esc_col(pkey)}`"
-			end
-			
-			sql << ")"
-    end
-    
-    sql << ")"
-    sql << " TABLESPACE #{args[:tablespace]}" if args[:tablespace]
-    sql << " ENGINE=#{args[:engine]}" if args[:engine]
-    sql << ";"
-    
-    puts sql
-    
-    #Create table.
-    @db.query(sql)
-    
-    
-    #Insert data of previous data in a single query.
-    @db.query("INSERT INTO `#{newname}` SELECT * FROM `#{self.name}`")
-    
-    
-    #Create indexes.
-    new_table = @db.tables[newname]
-    indexes_list = []
-    self.indexes do |index|
-			indexes_list << index.data if !index.primary?
-    end
-    
-    new_table.create_indexes(indexes_list)
-    
-    
-    #Return new table.
-    return new_table
-  end
-  
-  #Changes the engine for a table.
-  def engine=(newengine)
-		raise "Invalid engine: '#{newengine}'." if !newengine.to_s.match(/^[A-z]+$/)
-		@db.query("ALTER TABLE `#{@db.esc_table(self.name)}` ENGINE = #{newengine}") if self.engine.to_s != newengine.to_s
-		@data[:Engine] = newengine
-  end
-end