knjrbfw 0.0.39 → 0.0.40

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

@@ -1,6 +1,8 @@
+#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]
@@ -10,6 +12,7 @@ class KnjDB_mysql::Tables
     @list_should_be_reloaded = true
   end
   
+  #Cleans the wref-map.
   def clean
     @list.clean
   end
@@ -31,6 +34,7 @@ class KnjDB_mysql::Tables
     raise Knj::Errors::NotFound.new("Table was not found: #{table_name}.")
   end
   
+  #Yields the tables of the current database.
   def list(args = {})
     ret = {} unless block_given?
     
@@ -66,7 +70,8 @@ class KnjDB_mysql::Tables
     end
   end
   
-  def create(name, data)
+  #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 TABLE `#{name}` ("
@@ -91,6 +96,8 @@ class KnjDB_mysql::Tables
     end
     
     sql << ")"
+    
+    return [sql] if args and args[:return_sql]
     @db.query(sql)
   end
 end
@@ -106,7 +113,7 @@ class KnjDB_mysql::Tables::Table
     @list = Wref_map.new
     @indexes_list = Wref_map.new
     
-    raise "Could not figure out name from: '#{@data}'." if !@data[:Name]
+    raise "Could not figure out name from: '#{@data}'." if @data[:Name].to_s.strip.length <= 0
   end
   
   def reload
@@ -321,7 +328,7 @@ class KnjDB_mysql::Tables::Table
   
   def data
     ret = {
-      "name" => name,
+      "name" => self.name,
       "columns" => [],
       "indexes" => []
     }

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

@@ -1,7 +1,9 @@
+#This class handels SQLite3-specific behaviour.
 class KnjDB_sqlite3
   attr_reader :knjdb, :conn, :escape_table, :escape_col, :escape_val, :esc_table, :esc_col, :symbolize
   attr_accessor :tables, :cols, :indexes
   
+  #Constructor. This should not be called manually.
   def initialize(knjdb_ob)
     @escape_table = "`"
     @escape_col = "`"
@@ -37,6 +39,7 @@ class KnjDB_sqlite3
     end
   end
   
+  #Executes a query against the driver.
   def query(string)
     begin
       if @knjdb.opts[:subtype] == "rhodes"
@@ -60,12 +63,17 @@ class KnjDB_sqlite3
     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(@escape_col) != nil
@@ -75,16 +83,26 @@ class KnjDB_sqlite3
   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
@@ -108,6 +126,7 @@ class KnjDB_sqlite3_result_java
     end
   end
   
+  #Returns a single result.
   def fetch
     return false if !@rows
     ret = @rows[@index]
@@ -116,6 +135,7 @@ class KnjDB_sqlite3_result_java
     return ret
   end
   
+  #Loops over every result and yields them.
   def each
     while data = self.fetch
       yield(data)
@@ -123,7 +143,9 @@ class KnjDB_sqlite3_result_java
   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
@@ -135,6 +157,7 @@ class KnjDB_sqlite3_result
     end
   end
   
+  #Returns a single result.
   def fetch
     result_hash = @result_array[@index]
     return false if !result_hash
@@ -154,6 +177,7 @@ class KnjDB_sqlite3_result
     return ret
   end
   
+  #Loops over every result yielding them.
   def each
     while data = self.fetch
       yield(data)

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

@@ -1,12 +1,13 @@
+#This class handels the SQLite3-specific behaviour for columns.
 class KnjDB_sqlite3::Columns
-  attr_reader :db, :driver
+  attr_reader :db
   
+  #Constructor. This should not be called manually.
   def initialize(args)
     @args = args
-    @db = @args[:db]
-    @driver = @args[:driver]
   end
   
+  #Returns SQL for a knjdb-compatible hash.
   def data_sql(data)
     raise "No type given." if !data["type"]
     type = data["type"]
@@ -17,7 +18,7 @@ class KnjDB_sqlite3::Columns
     end
     
     data["maxlength"] = 255 if type == "varchar" and !data.key?("maxlength")
-    type = "integer" if @db.int_types.index(type) and (data["autoincr"] or 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"]
@@ -28,29 +29,34 @@ class KnjDB_sqlite3::Columns
     if data.key?("default_func")
       sql << " DEFAULT #{data["default_func"]}"
     elsif data.key?("default") and data["default"] != false
-      sql << " DEFAULT '#{@db.escape(data["default"])}'"
+      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,
@@ -63,6 +69,7 @@ class KnjDB_sqlite3::Columns::Column
     }
   end
   
+  #Returns the type of the column.
   def type
     if !@type
       if match = @args[:data][:type].match(/^([A-z]+)$/)
@@ -70,36 +77,41 @@ class KnjDB_sqlite3::Columns::Column
         type = match[0]
       elsif match = @args[:data][:type].match(/^decimal\((\d+),(\d+)\)$/)
         @maxlength = "#{match[1]},#{match[2]}"
-        type = "decimal"
+        type = :decimal
       elsif match = @args[:data][:type].match(/^enum\((.+)\)$/)
         @maxlength = match[1]
-        type = "enum"
+        type = :enum
       elsif match = @args[:data][:type].match(/^(.+)\((\d+)\)$/)
         @maxlength = match[2]
-        type = match[1]
+        type = match[1].to_sym
       end
       
-      if type == "integer"
-        @type = "int"
+      if type == :integer
+        @type = :int
       else
         @type = type
       end
+      
+      raise "Still not type?" 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
+    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) == "'"
@@ -114,24 +126,26 @@ class KnjDB_sqlite3::Columns::Column
     return def_val
   end
   
+  #Returns true if the column is the primary key.
   def primarykey?
-    return true if @args[:data][:name] == "id"
+    return true if self.name.to_s == "id"
     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][:name] == "id"
+    return true if self.name.to_s == "id"
     return true if @args[:data][:pk].to_i >= 1
     return false
   end
   
+  #Drops the column from the table.
   def drop
-    @args[:table].copy(
-      "drops" => self.name
-    )
+    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
     

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

@@ -13,16 +13,17 @@ class KnjDB_sqlite3::Tables
     table_name = table_name.to_s
     
     begin
-      return @list[table_name]
+      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
+      return table_obj if table_obj.name.to_s == table_name.to_s
     end
     
-    raise Knj::Errors::NotFound.new("Table was not found: #{table_name}.")
+    raise Knj::Errors::NotFound, "Table was not found: #{table_name}."
   end
   
   def list
@@ -55,7 +56,7 @@ class KnjDB_sqlite3::Tables
     end
   end
   
-  def create(name, data)
+  def create(name, data, args = nil)
     sql = "CREATE TABLE `#{name}` ("
     
     first = true
@@ -67,11 +68,26 @@ class KnjDB_sqlite3::Tables
     
     sql << ")"
     
-    @db.query(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]
-      table_obj.create_indexes(data["indexes"])
+      
+      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
@@ -89,6 +105,14 @@ class KnjDB_sqlite3::Tables::Table
     return @data[:name]
   end
   
+  def type
+    return @data[:type]
+  end
+  
+  def maxlength
+    return @data[:maxlength]
+  end
+  
   def drop
     sql = "DROP TABLE `#{self.name}`"
     @db.query(sql)
@@ -98,6 +122,11 @@ class KnjDB_sqlite3::Tables::Table
     raise "stub!"
   end
   
+  def truncate
+    @db.query("DELETE FROM `#{self.name}` WHERE 1=1")
+    return nil
+  end
+  
   def table
     return @db.tables[@table_name]
   end
@@ -331,7 +360,11 @@ class KnjDB_sqlite3::Tables::Table
     end
   end
   
-  def create_indexes(index_arr)
+  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]}
@@ -355,7 +388,17 @@ class KnjDB_sqlite3::Tables::Table
       
       sql << ")"
       
-      @db.query(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
   

data/lib/knj/knjdb/dump.rb

@@ -0,0 +1,121 @@
+#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
+    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_name, table_obj|
+      table_obj = @args[:db].tables[table_obj] if table_obj.is_a?(String) or table_obj.is_a?(Symbol)
+      
+      #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

@@ -0,0 +1,109 @@
+#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