baza 0.0.14 → 0.0.15

data/include/drivers/sqlite3/sqlite3_result.rb

@@ -0,0 +1,35 @@
+#This class handels the result when running MRI (or others).
+class Baza::Driver::Sqlite3::Result
+  #Constructor. This should not be called manually.
+  def initialize(driver, result_array)
+    @result_array = result_array
+    @index = 0
+  end
+
+  #Returns a single result.
+  def fetch
+    result_hash = @result_array[@index]
+    return false unless result_hash
+    @index += 1
+
+    ret = {}
+    result_hash.each do |key, val|
+      if (Float(key) rescue false)
+        #do nothing.
+      elsif !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/include/drivers/sqlite3/sqlite3_result_java.rb

@@ -0,0 +1,39 @@
+#This class handels results when running in JRuby.
+class Baza::Driver::Sqlite3::ResultJava
+  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).to_sym
+          row_data[col_name] = rs.getString(i)
+        end
+
+        @rows << row_data
+      end
+    end
+  end
+
+  #Returns a single result.
+  def fetch
+    return false unless @rows
+    ret = @rows[@index]
+    return false unless ret
+    @index += 1
+    return ret
+  end
+
+  #Loops over every result and yields them.
+  def each
+    while data = fetch
+      yield data
+    end
+  end
+end

data/include/drivers/sqlite3/sqlite3_table.rb

@@ -0,0 +1,399 @@
+class Baza::Driver::Sqlite3::Table
+  attr_reader :name, :type
+
+  def initialize(args)
+    @db = args[:db]
+    @data = args[:data]
+    @name = @data[:name].to_sym
+    @type = @data[:type].to_sym
+    @tables = args[:tables]
+
+    @list = Wref_map.new
+    @indexes_list = Wref_map.new
+  end
+
+  def maxlength
+    return @data[:maxlength]
+  end
+
+  def reload
+    @data = @db.select("sqlite_master", {type: "table", name: name}, {orderby: "name"}).fetch
+  end
+
+  def rows_count
+    data = @db.q("SELECT COUNT(*) AS count FROM `#{name}`").fetch
+    return data[:count].to_i
+  end
+
+  #Drops the table from the database.
+  def drop
+    raise "Cant drop native table: '#{name}'." if native?
+    @db.query("DROP TABLE `#{name}`")
+    @tables.remove_from_list(self) if @tables.exists_in_list?(self)
+  end
+
+  #Returns true if the table is safe to drop.
+  def native?
+    return true if name.to_s == "sqlite_sequence"
+    return false
+  end
+
+  def optimize
+    # Not possible in SQLite3.
+  end
+
+  def rename(newname)
+    newname = newname.to_sym
+
+    @tables.remove_from_list(self)
+    newtable = clone(newname)
+    @db.tables.remove_from_list(newtable)
+    drop
+    @data[:name] = newname
+    @name = newname
+    @tables.add_to_list(self)
+
+    #Rename table on all columns and indexes.
+    @list.each do |name, column|
+      column.args[:table_name] = newname
+    end
+
+    @indexes_list.each do |name, index|
+      index.args[:table_name] = newname
+    end
+  end
+
+  def truncate
+    @db.query("DELETE FROM `#{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, "Column not found: #{name}."
+  end
+
+  def columns
+    @db.cols
+    ret = {}
+
+    @db.q("PRAGMA table_info(`#{@db.esc_table(name)}`)") do |d_cols|
+      column_name = d_cols[:name].to_sym
+      obj = @list.get!(column_name)
+
+      unless obj
+        obj = Baza::Driver::Sqlite3::Column.new(
+          table_name: name,
+          db: @db,
+          data: d_cols
+        )
+        @list[column_name] = obj
+      end
+
+      if block_given?
+        yield obj
+      else
+        ret[column_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, args = nil)
+    raise "Invalid name." if newname.to_s.strip.empty?
+
+    sql = "CREATE TABLE `#{newname}` ("
+    first = true
+    columns.each do |name, col|
+      sql << ", " unless first
+      first = false if first
+      sql << @db.cols.data_sql(col.data)
+    end
+
+    sql << ");"
+    @db.query(sql)
+    @db.query("INSERT INTO `#{newname}` SELECT * FROM `#{name}`")
+
+    indexes_to_create = []
+    new_table = @db.tables[newname.to_sym]
+    indexes.each do |name, index|
+      index_name = name.to_s
+
+      if @db.opts[:index_append_table_name] && match = index_name.match(/\A(.+?)__(.+)\Z/)
+        index_name = match[2]
+      end
+
+      create_data = index.data
+      create_data[:name] = index_name
+
+      indexes_to_create << create_data
+    end
+
+    new_table.create_indexes(indexes_to_create)
+
+    if args && args[:return_table] == false
+      return nil
+    else
+      return new_table
+    end
+  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] && args[:drops].to_s.include?(name.to_s)
+
+      sql << ", " if !first
+      first = false if first
+
+      if args.key?(:alter_columns) && args[:alter_columns][name.to_sym]
+        sql << @db.cols.data_sql(args[:alter_columns][name.to_sym])
+      else
+        sql << @db.cols.data_sql(col.data)
+      end
+
+      if args[:new]
+        args[:new].each do |col_data|
+          if col_data[:after] && 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] && args[:drops].to_s.include?(name.to_s)
+
+      sql << ", " if !first
+      first = false if first
+
+      sql << "`#{name}`"
+
+      if args[:news]
+        args[:news].each do |col_data|
+          if col_data[:after] && col_data[:after] == name.to_s
+            sql << ", ''"
+          end
+        end
+      end
+    end
+
+    sql << " FROM `#{temp_name}`"
+    @db.query(sql)
+    @db.query("DROP TABLE `#{temp_name}`")
+  end
+
+  def index index_name
+    index_name = index_name.to_sym
+
+    begin
+      return @indexes_list[index_name]
+    rescue Wref::Recycled
+      if @db.opts[:index_append_table_name]
+        tryname = "#{name}__#{index_name}"
+
+        begin
+          return @indexes_list[tryname]
+        rescue Wref::Recycled
+          #ignore.
+        end
+      end
+    end
+
+    indexes do |index|
+      if index.name.to_s == "#{name}__#{index_name}"
+        return index
+      end
+
+      return index if index.name.to_s == index_name.to_s
+    end
+
+    raise Errno::ENOENT, "Index not found: #{index_name}."
+  end
+
+  def indexes
+    @db.indexes
+    ret = {} unless block_given?
+
+    @db.q("PRAGMA index_list(`#{@db.esc_table(name)}`)") do |d_indexes|
+      next if d_indexes[:Key_name] == "PRIMARY"
+      obj = @indexes_list.get!(d_indexes[:name])
+
+      unless obj
+        obj = Baza::Driver::Sqlite3::Index.new(
+          table_name: name,
+          db: @db,
+          data: d_indexes
+        )
+
+        @indexes_list[d_indexes[:name].to_sym] = obj
+
+        # Get columns from index.
+        index_master_data = @db.single(:sqlite_master, type: "index", name: d_indexes[:name])
+        parse_columns_from_sql(index_master_data[:sql]).each do |column|
+          obj.columns << column
+        end
+      end
+
+      if block_given?
+        yield(obj)
+      else
+        ret[d_indexes[:name].to_sym] = obj
+      end
+    end
+
+    if block_given?
+      return nil
+    else
+      return ret
+    end
+  end
+
+  def create_indexes(index_arr, args = nil)
+    if args && args[:return_sql]
+      ret = []
+    end
+
+    index_arr.each do |index_data|
+      if index_data.is_a?(String) or index_data.is_a?(Symbol)
+        index_data = {name: index_data, columns: [index_data]}
+      end
+
+      raise "No name was given in data: '#{index_data}'." if !index_data.key?(:name) or index_data[:name].to_s.strip.empty?
+      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"
+      sql << " UNIQUE" if index_data[:unique]
+      sql << " 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 && args[:return_sql]
+        ret << sql
+      else
+        @db.query(sql)
+      end
+    end
+
+    if args && 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(name, data)
+  end
+
+  def to_s
+    "#<Baza::Driver::Sqlite3::Table name: \"#{name}\">"
+  end
+
+  def inspect
+    to_s
+  end
+
+private
+
+  def parse_columns_from_sql sql
+    columns_sql = sql.match(/\((.+?)\)\Z/)[1]
+    return columns_sql.split(",").map{ |column| column[1, column.length - 2] }
+  end
+end