baza 0.0.0

data/include/drivers/mysql/mysql_columns.rb

@@ -0,0 +1,155 @@
+#This class handels various MySQL-column-specific operations.
+class Baza::Driver::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 Baza::Driver::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/include/drivers/mysql/mysql_indexes.rb

@@ -0,0 +1,69 @@
+class Baza::Driver::Mysql::Indexes
+  def initialize(args)
+    @args = args
+  end
+end
+
+class Baza::Driver::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/include/drivers/mysql/mysql_sqlspecs.rb

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

data/include/drivers/mysql/mysql_tables.rb

@@ -0,0 +1,443 @@
+require "monitor"
+
+#This class handels various MySQL-table-specific behaviour.
+class Baza::Driver::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 = Baza::Driver::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 << Baza::Driver::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 Baza::Driver::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 = Baza::Driver::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 = Baza::Driver::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 Baza::Driver::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