baza 0.0.0

data/include/query_buffer.rb

@@ -0,0 +1,87 @@
+#This class buffers a lot of queries and flushes them out via transactions.
+class Baza::QueryBuffer
+  #Constructor. Takes arguments to be used and a block.
+  def initialize(args)
+    @args = args
+    @queries = []
+    @inserts = {}
+    @queries_count = 0
+    @debug = @args[:debug]
+    @lock = Mutex.new
+    
+    STDOUT.puts "Query buffer started." if @debug
+    
+    if block_given?
+			begin
+				yield(self)
+			ensure
+				self.flush
+			end
+		end
+  end
+  
+  #Adds a query to the buffer.
+  def query(str)
+    @lock.synchronize do
+      STDOUT.print "Adding to buffer: #{str}\n" if @debug
+      @queries << str
+      @queries_count += 1
+    end
+    
+    self.flush if @queries_count >= 1000
+    return nil
+  end
+  
+  #Delete as on a normal Baza::Db.
+  #===Examples
+  # db.q_buffer do |buffer|
+  #   buffer.delete(:users, {:id => 5})
+  # end
+  def delete(table, where)
+    STDOUT.puts "Delete called on table #{table} with arguments: '#{where}'." if @debug
+    self.query(@args[:db].delete(table, where, :return_sql => true))
+    return nil
+  end
+  
+  #Plans to inset a hash into a table. It will only be inserted when flush is called.
+  #===Examples
+  # db.q_buffer do |buffer|
+  #   buffer.insert(:users, {:name => "John Doe"})
+  # end
+  def insert(table, data)
+    @lock.synchronize do
+      @inserts[table] = [] if !@inserts.key?(table)
+      @inserts[table] << data
+      @queries_count += 1
+    end
+    
+    self.flush if @queries_count >= 1000
+    return nil
+  end
+  
+  #Flushes all queries out in a transaction. This will automatically be called for every 1000 queries.
+  def flush
+    return nil if @queries_count <= 0
+    
+    @lock.synchronize do
+      @args[:db].transaction do
+        @queries.shift(1000).each do |str|
+          STDOUT.print "Executing via buffer: #{str}\n" if @debug
+          @args[:db].q(str)
+        end
+        
+        @inserts.each do |table, datas_arr|
+          while !datas_arr.empty?
+            datas_chunk_arr = datas_arr.shift(1000)
+            @args[:db].insert_multi(table, datas_chunk_arr)
+          end
+        end
+      end
+      
+      @inserts.clear
+      @queries_count = 0
+    end
+    
+    return nil
+  end
+end

data/include/revision.rb

@@ -0,0 +1,342 @@
+#This class takes a database-schema from a hash and runs it against the database. It then checks that the database matches the given schema.
+#
+#===Examples
+# db = Baza::Db.new(:type => "sqlite3", :path => "test_db.sqlite3")
+# schema = {
+#   "tables" => {
+#     "User" => {
+#       "columns" => [
+#         {"name" => "id", "type" => "int", "autoincr" => true, "primarykey" => true},
+#         {"name" => "name", "type" => "varchar"},
+#         {"name" => "lastname", "type" => "varchar"}
+#       ],
+#       "indexes" => [
+#         "name",
+#         {"name" => "lastname", "columns" => ["lastname"]}
+#       ],
+#       "on_create_after" => proc{|d|
+#         d["db"].insert("User", {"name" => "John", "lastname" => "Doe"})
+#       }
+#     }
+#   }
+# }
+# 
+# rev = Baza::Revision.new
+# rev.init_db("db" => db, "schema" => schema)
+class Baza::Revision
+  def initialize(args = {})
+    @args = args
+  end
+  
+  #This initializes a database-structure and content based on a schema-hash.
+  #===Examples
+  # dbrev = Baza::Revision.new
+  # dbrev.init_db("db" => db_obj, "schema" => schema_hash)
+  def init_db(args)
+    schema = args["schema"]
+    db = args["db"]
+    
+    #Check for normal bugs and raise apropiate error.
+    raise "'schema' argument was not a Hash: '#{schema.class.name}'." if !schema.is_a?(Hash)
+    raise "':return_keys' is not 'symbols' - Knjdbrevision will not work without it." if db.opts[:return_keys] != "symbols"
+    raise "No tables given." if !schema.has_key?("tables")
+    
+    #Cache tables to avoid constant reloading.
+    if !args.key?("tables_cache") or args["tables_cache"]
+      print "Caching tables-list.\n" if args["debug"]
+      tables = db.tables.list
+    else
+      print "Skipping tables-cache.\n" if args["debug"]
+    end
+    
+    schema["tables"].each do |table_name, table_data|
+      begin
+        begin
+          table_obj = db.tables[table_name]
+          
+          #Cache indexes- and column-objects to avoid constant reloading.
+          cols = table_obj.columns
+          indexes = table_obj.indexes
+          
+          if table_data["columns"]
+            first_col = true
+            table_data["columns"].each do |col_data|
+              begin
+                col_obj = table_obj.column(col_data["name"])
+                col_str = "#{table_name}.#{col_obj.name}"
+                type = col_data["type"].to_s
+                dochange = false
+                
+                if !first_col and !col_data["after"]
+                  #Try to find out the previous column - if so we can set "after" which makes the column being created in the right order as defined.
+                  if !col_data.has_key?("after")
+                    prev_no = table_data["columns"].index(col_data)
+                    if prev_no != nil and prev_no != 0
+                      prev_no = prev_no - 1
+                      prev_col_data = table_data["columns"][prev_no]
+                      col_data["after"] = prev_col_data["name"]
+                    end
+                  end
+                  
+                  actual_after = nil
+                  set_next = false
+                  cols.each do |col_name, col_iter|
+                    if col_iter.name == col_obj.name
+                      break
+                    else
+                      actual_after = col_iter.name
+                    end
+                  end
+                  
+                  if actual_after != col_data["after"]
+                    print "Changing '#{col_str}' after from '#{actual_after}' to '#{col_data["after"]}'.\n" if args["debug"]
+                    dochange = true
+                  end
+                end
+                
+                #BUGFIX: When using SQLite3 the primary-column or a autoincr-column may never change type from int... This will break it!
+                if db.opts[:type] == "sqlite3" and col_obj.type.to_s == "int" and (col_data["primarykey"] or col_data["autoincr"]) and db.int_types.index(col_data["type"].to_s)
+                  type = "int"
+                end
+                
+                if type and col_obj.type.to_s != type
+                  print "Type mismatch on #{col_str}: #{col_data["type"]}, #{col_obj.type}\n" if args["debug"]
+                  dochange = true
+                end
+                
+                if col_data.has_key?("primarykey") and col_obj.primarykey? != col_data["primarykey"]
+                  print "Primary-key mismatch for #{col_str}: #{col_data["primarykey"]}, #{col_obj.primarykey?}\n" if args["debug"]
+                  dochange = true
+                end
+                
+                if col_data.has_key?("autoincr") and col_obj.autoincr? != col_data["autoincr"]
+                  print "Auto-increment mismatch for #{col_str}: #{col_data["autoincr"]}, #{col_obj.autoincr?}\n" if args["debug"]
+                  dochange = true
+                end
+                
+                if col_data.has_key?("maxlength") and col_obj.maxlength.to_s != col_data["maxlength"].to_s
+                  print "Maxlength mismatch on #{col_str}: #{col_data["maxlength"]}, #{col_obj.maxlength}\n" if args["debug"]
+                  dochange = true
+                end
+                
+                if col_data.has_key?("null") and col_obj.null?.to_s != col_data["null"].to_s
+                  print "Null mismatch on #{col_str}: #{col_data["null"]}, #{col_obj.null?}\n" if args["debug"]
+                  dochange = true
+                end
+                
+                if col_data.has_key?("default") and col_obj.default.to_s != col_data["default"].to_s
+                  print "Default mismatch on #{col_str}: #{col_data["default"]}, #{col_obj.default}\n" if args["debug"]
+                  dochange = true
+                end
+                
+                if col_data.has_key?("comment") and col_obj.respond_to?(:comment) and col_obj.comment.to_s != col_data["comment"].to_s
+                  print "Comment mismatch on #{col_str}: #{col_data["comment"]}, #{col_obj.comment}\n" if args["debug"]
+                  dochange = true
+                end
+                
+                if col_data.is_a?(Hash) and col_data["on_before_alter"]
+                  callback_data = col_data["on_before_alter"].call("db" => db, "table" => table_obj, "col" => col_obj, "col_data" => col_data)
+                  if callback_data and callback_data["action"]
+                    if callback_data["action"] == "retry"
+                      raise Knj::Errors::Retry
+                    end
+                  end
+                end
+                
+                if dochange
+                  col_obj.change(col_data)
+                  
+                  #Change has been made - update cache.
+                  cols = table_obj.columns
+                end
+                
+                first_col = false
+              rescue Errno::ENOENT => e
+                print "Column not found: #{table_obj.name}.#{col_data["name"]}.\n" if args["debug"]
+                
+                if col_data.has_key?("renames")
+                  raise "'renames' was not an array for column '#{table_obj.name}.#{col_data["name"]}'." if !col_data["renames"].is_a?(Array)
+                  
+                  rename_found = false
+                  col_data["renames"].each do |col_name|
+                    begin
+                      col_rename = table_obj.column(col_name)
+                    rescue Errno::ENOENT => e
+                      next
+                    end
+                    
+                    print "Rename #{table_obj.name}.#{col_name} to #{table_obj.name}.#{col_data["name"]}\n" if args["debug"]
+                    if col_data.is_a?(Hash) and col_data["on_before_rename"]
+                      col_data["on_before_rename"].call("db" => db, "table" => table_obj, "col" => col_rename, "col_data" => col_data)
+                    end
+                    
+                    col_rename.change(col_data)
+                    
+                    #Change has been made - update cache.
+                    cols = table_obj.columns
+                    
+                    if col_data.is_a?(Hash) and col_data["on_after_rename"]
+                      col_data["on_after_rename"].call("db" => db, "table" => table_obj, "col" => col_rename, "col_data" => col_data)
+                    end
+                    
+                    rename_found = true
+                    break
+                  end
+                  
+                  retry if rename_found
+                end
+                
+                oncreated = col_data["on_created"]
+                col_data.delete("on_created") if col_data["oncreated"]
+                col_obj = table_obj.create_columns([col_data])
+                
+                #Change has been made - update cache.
+                cols = table_obj.columns
+                
+                oncreated.call("db" => db, "table" => table_obj) if oncreated
+              end
+            end
+          end
+          
+          if table_data["columns_remove"]
+            table_data["columns_remove"].each do |column_name, column_data|
+              begin
+                col_obj = table_obj.column(column_name)
+              rescue Errno::ENOENT => e
+                next
+              end
+              
+              column_data["callback"].call if column_data.is_a?(Hash) and column_data["callback"]
+              col_obj.drop
+            end
+          end
+          
+          if table_data["indexes"]
+            table_data["indexes"].each do |index_data|
+              if index_data.is_a?(String)
+                index_data = {"name" => index_data, "columns" => [index_data]}
+              end
+              
+              begin
+                index_obj = table_obj.index(index_data["name"])
+                
+                rewrite_index = false
+                rewrite_index = true if index_data.key?("unique") and index_data["unique"] != index_obj.unique?
+                
+                if rewrite_index
+                  index_obj.drop
+                  table_obj.create_indexes([index_data])
+                end
+              rescue Errno::ENOENT => e
+                table_obj.create_indexes([index_data])
+              end
+            end
+          end
+          
+          if table_data["indexes_remove"]
+            table_data["indexes_remove"].each do |index_name, index_data|
+              begin
+                index_obj = table_obj.index(index_name)
+              rescue Errno::ENOENT => e
+                next
+              end
+              
+              if index_data.is_a?(Hash) and index_data["callback"]
+                index_data["callback"].call if index_data["callback"]
+              end
+              
+              index_obj.drop
+            end
+          end
+          
+          rows_init("db" => db, "table" => table_obj, "rows" => table_data["rows"]) if table_data and table_data["rows"]
+        rescue Errno::ENOENT => e
+          if table_data.key?("renames")
+            table_data["renames"].each do |table_name_rename|
+              begin
+                table_rename = db.tables[table_name_rename.to_sym]
+                table_rename.rename(table_name)
+                raise Knj::Errors::Retry
+              rescue Errno::ENOENT
+                next
+              end
+            end
+          end
+          
+          if !table_data.key?("columns")
+            print "Notice: Skipping creation of '#{table_name}' because no columns were given in hash.\n"
+            next
+          end
+          
+          if table_data["on_create"]
+            table_data["on_create"].call("db" => db, "table_name" => table_name, "table_data" => table_data)
+          end
+          
+          db.tables.create(table_name, table_data)
+          table_obj = db.tables[table_name.to_sym]
+          
+          if table_data["on_create_after"]
+            table_data["on_create_after"].call("db" => db, "table_name" => table_name, "table_data" => table_data)
+          end
+          
+          rows_init("db" => db, "table" => table_obj, "rows" => table_data["rows"]) if table_data["rows"]
+        end
+      rescue Knj::Errors::Retry
+        retry
+      end
+    end
+    
+    if schema["tables_remove"]
+      schema["tables_remove"].each do |table_name, table_data|
+        begin
+          table_obj = db.tables[table_name.to_sym]
+          table_data["callback"].call("db" => db, "table" => table_obj) if table_data.is_a?(Hash) and table_data["callback"]
+          table_obj.drop
+        rescue Errno::ENOENT => e
+          next
+        end
+      end
+    end
+    
+    
+    #Free cache.
+    tables.clear if tables
+    tables = nil
+  end
+  
+  private
+  
+  #This method checks if certain rows are present in a table based on a hash.
+  def rows_init(args)
+    db = args["db"]
+    table = args["table"]
+    
+    raise "No db given." if !db
+    raise "No table given." if !table
+    
+    args["rows"].each do |row_data|
+      if row_data["find_by"]
+        find_by = row_data["find_by"]
+      elsif row_data["data"]
+        find_by = row_data["data"]
+      else
+        raise "Could not figure out the find-by."
+      end
+      
+      rows_found = 0
+      args["db"].select(table.name, find_by) do |d_rows|
+        rows_found += 1
+        
+        if Knj::ArrayExt.hash_diff?(Knj::ArrayExt.hash_sym(row_data["data"]), Knj::ArrayExt.hash_sym(d_rows), {"h2_to_h1" => false})
+          print "Data was not right - updating row: #{JSON.generate(row_data["data"])}\n" if args["debug"]
+          args["db"].update(table.name, row_data["data"], d_rows)
+        end
+      end
+      
+      if rows_found == 0
+        print "Inserting row: #{JSON.generate(row_data["data"])}\n" if args["debug"]
+        table.insert(row_data["data"])
+      end
+    end
+  end
+end

data/include/row.rb

@@ -0,0 +1,153 @@
+class Baza::Row
+  attr_reader :args, :data
+  
+  def is_knj?; return true; end
+  
+  def initialize(args)
+    @args = {}
+    args.each do |key, value|
+      @args[key.to_sym] = value
+    end
+    
+    @args[:db] = $db if !@args[:db] and $db and $db.class.to_s == "Baza::Db"
+    @args[:objects] = $objects if !@args[:objects] and $objects and $objects.is_a?(Baza::ModelHandler)
+    @args[:col_id] = :id if !@args[:col_id]
+    raise "No table given." if !@args[:table]
+    
+    if @args[:data] and (@args[:data].is_a?(Integer) or @args[:data].is_a?(Fixnum) or @args[:data].is_a?(String))
+      @data = {@args[:col_id].to_sym => @args[:data].to_s}
+      self.reload
+    elsif @args[:data] and @args[:data].is_a?(Hash)
+      @data = {}
+      @args[:data].each do |key, value|
+        @data[key.to_sym] = value
+      end
+    elsif @args[:id]
+      @data = {}
+      @data[@args[:col_id].to_sym] = @args[:id]
+      self.reload
+    else
+      raise ArgumentError.new("Invalid data: #{@args[:data].to_s} (#{@args[:data].class.to_s})")
+    end
+  end
+  
+  def db
+    if !@args[:force_selfdb]
+      curthread = Thread.current
+      if curthread.is_a?(Knj::Thread) and curthread[:knjappserver] and curthread[:knjappserver][:db]
+        return curthread[:knjappserver][:db]
+      end
+    end
+    
+    return @args[:db]
+  end
+  
+  def ob
+    return @args[:objects] if @args.key?(:objects)
+    return $ob if $ob and $ob.is_a?(Baza::ModelHandler)
+    return false
+  end
+  
+  alias :objects :ob
+  
+  def reload
+    last_id = self.id
+    data = self.db.single(@args[:table], {@args[:col_id] => self.id})
+    if !data
+      raise Errno::ENOENT.new("Could not find any data for the object with ID: '#{last_id}' in the table '#{@args[:table].to_s}'.")
+    end
+    
+    @data = {}
+    data.each do |key, value|
+      @data[key.to_sym] = value
+    end
+  end
+  
+  def update(newdata)
+    self.db.update(@args[:table], newdata, {@args[:col_id] => self.id})
+    self.reload
+    
+    if self.ob
+      self.ob.call("object" => self, "signal" => "update")
+    end
+  end
+  
+  def delete
+    self.db.delete(@args[:table], {@args[:col_id] => self.id})
+    self.destroy
+  end
+  
+  def destroy
+    @args = nil
+    @data = nil
+  end
+  
+  def has_key?(key)
+    return @data.key?(key.to_sym)
+  end
+  
+  def [](key)
+    raise "No valid key given." if !key
+    raise "No data was loaded on the object? Maybe you are trying to call a deleted object?" if !@data
+    
+    if @data.key?(key)
+      return @data[key]
+    elsif @data.key?(key.to_sym)
+      return @data[key.to_sym]
+    elsif @data.key?(key.to_s)
+      return @data[key.to_s]
+    end
+    
+    raise "No such key: #{key.to_s}."
+  end
+  
+  def []=(key, value)
+    self.update(key.to_sym => value)
+    self.reload
+  end
+  
+  def id
+    return @data[@args[:col_id]]
+  end
+  
+  def title
+    if @args[:col_title]
+      return @data[@args[:col_title].to_sym]
+    end
+    
+    if @data.key?(:title)
+      return @data[:title]
+    elsif @data.key?(:name)
+      return @data[:name]
+    end
+    
+    raise "'col_title' has not been set for the class: '#{self.class.to_s}'."
+  end
+  
+  alias :name :title
+  
+  def each(&args)
+    return @data.each(&args)
+  end
+  
+  def to_hash
+    return @data.clone
+  end
+  
+  def esc(str)
+    return self.db.escape(str)
+  end
+  
+  def method_missing(*args)
+    func_name = args[0].to_s
+    if match = func_name.match(/^(\S+)\?$/) and @data.key?(match[1].to_sym)
+      if @data[match[1].to_sym] == "1" or @data[match[1].to_sym] == "yes"
+        return true
+      elsif @data[match[1].to_sym] == "0" or @data[match[1].to_sym] == "no"
+        return false
+      end
+    end
+    
+    raise sprintf("No such method: %s", func_name)
+  end
+end