knjrbfw 0.0.110 → 0.0.114

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

data/lib/knj/knjdb/dump.rb

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

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