shalmaneser 1.2.0.rc4 → 1.2.rc5

data/lib/db/db_sqlite.rb

@@ -1,280 +0,0 @@
-# DBSQLite: a subclass of DBWrapper.
-#
-# Use SQLite to access a database.
-# Use the Ruby sqlite3 interface package for that.
-
-require 'sqlite3'
-require 'tempfile'
-
-require 'db/db_wrapper'
-
-#################
-class DBSQLiteResult < DBResult
-  # initialize with the result of SQLite::execute()
-  # which returns an array of rows
-  # Each row is an array
-  # but additionally has attributes
-  # - fields: returns an array of strings, the column names
-  # - types: returns an array of strings, the column types
-  def initialize(value)
-    super(value)
-    @counter = 0
-  end
-
-  ###
-  # column names: list of strings
-  def list_column_names()
-    return @result.columns
-  end
-
-  # number of rows: returns an integer
-  def num_rows()
-    # remember where we were in iterating over items
-    tmp_counter = @counter
-    
-    # reset, and iterate over all rows to count
-    reset()
-    retv = 0
-    each { |x| retv += 1}
-    
-    # return to where we were in iterating over items
-    reset()
-    while @counter < tmp_counter
-      @result.next()
-      @counter += 1
-    end
-
-    # and return the number of rows
-    return retv
-  end
-
-
-  # yields each row as an array of values
-  def each()
-    @result.each { |row| 
-      @counter += 1
-      yield row.map { |x| x.to_s() }
-    }
-  end
-
-  # yields each row as a hash: column name=> column value
-  def each_hash()
-    @result.each { |row| 
-      @counter += 1
-
-      row_hash = Hash.new()
-      row.fields.each_with_index { |key, index|
-        row_hash[key] = row[index].to_s()
-      }
-      yield row_hash
-    }
-  end
-
-
-  ###
-  # reset such that each() can be run again on the result object
-  def reset()
-    @result.reset()
-    @counter = 0
-  end
-
-  # free object
-  def free()
-    @result.close()
-  end
-
-  # returns row as an array of column contents
-  def fetch_row()
-    @counter += 1
-    return @result.next()
-  end
-end
-
-#################
-class DBSQLite < DBWrapper
-
-  ###
-  # initialization: 
-  #
-  # open database file according to the given identifier
-  def initialize(exp,  # RosyConfigData experiment file object
-                 dir = nil,  # string: directory for Shalmaneser internal data, ends in "/"
-                 identifier = nil) # string: identifier to use for the database
-    super(exp)
-
-    # dir and identifier may be nil, if we're only opening this object
-    # in order to make temp databases
-    if dir and identifier
-      @database = SQLite3::Database.new(dir + identifier.to_s + ".db")
-    else
-      @database = nil
-    end
-
-    # temp file for temp database
-    @tf = nil
-  end
-
-  ###
-  # make a table
-  #
-  # returns: nothing
-  def create_table(table_name, # string
-                   column_formats, # array: array: string*string [column_name,column_format]
-                   index_column_names, # array: string: column_name
-                   indexname)  # string: name of automatically created index column   
-
-    # primary key and auto-increment column 
-    string = "CREATE TABLE #{table_name} (" +
-      "#{indexname} INTEGER PRIMARY KEY"
-
-    # column declarations
-    unless column_formats.empty?
-      string << ", "
-      string << column_formats.map { |name, format| 
-        # include other keys
-        if index_column_names.include? name
-          name.to_s + " KEY " + format.to_s
-        else
-          name.to_s + " " + format.to_s 
-        end          
-      }.join(",")
-    end
-    string << ");"
-
-    query_noretv(string)
-  end
-
-  ###
-  # remove a table
-  def drop_table(table_name)
-    query_noretv("DROP TABLE " + table_name)
-  end
-
-  ###
-  def query(query)
-    if @database
-      return DBSQLiteResult.new(@database.query(query))
-    else
-      return nil
-    end
-  end
-
-  ####
-  # querying the database:
-  # no result value
-  def query_noretv(query)
-    if @database
-      @database.execute(query)
-    end
-    return nil
-  end
-
-  ###
-  # list all tables in the database
-  #
-  # array of strings
-  def list_tables()
-    if @database
-      return @database.execute("select name from sqlite_master;").map { |t|
-        t.to_s()
-      }
-    else
-      return nil
-    end
-  end
-
-  #####
-  # list_column_formats
-  #
-  # list column names and column types of this table
-  #
-  # returns: array:string*string, list of pairs [column name, column format]
-  def list_column_formats(table_name)
-    unless @database
-      return nil
-    end
-
-    table_descr = @database.execute("select * from sqlite_master where name=='#{table_name}';")
-      # this is an array of pieces of table description.
-      # the piece in the column called 'sql' is the 'create' statement. 
-    # get the 'create' statement
-    begin
-      field_names = table_descr[0].fields
-    rescue
-      $stderr.puts "SQLite error: could not read description of table #{table_name}"
-      exit 1
-    end
-    create_index = (0..field_names.length()).detect { |ix| field_names[ix] == 'sql' }
-
-    # try to parse column names out of the 'create' statement
-    if table_descr[0][create_index] =~ /^\s*create table \S+\s*\((.*)\)\s*$/i
-      # we now have something of shape ' a key varchar2(30), b varchar2(30)'
-      # split at the comma, remove whitespace at beginning and end
-      # then split again to get pairs [column name, column format]
-      return $1.split(",").map { |col_descrip|
-        pieces = col_descrip.strip().split().reject { |entry| 
-          entry =~ /^key$/i or  entry =~ /^primary$/i 
-        }
-        if pieces.length() > 2
-          $stderr.puts "Warning: problematic column format in #{col_descrip}, may be parsed wrong."
-        end
-        pieces
-      }
-    else
-      $stderr.puts "SQLite error: cannot read column names"
-      exit 1
-    end
-  end
-
-  ####
-  # num_rows
-  #
-  # determine the number of rows in a table
-  # returns: integer or nil
-  def num_rows(table_name)
-    unless @database
-      return nil
-    end
-
-    rows_s = @database.get_first_value( "select count(*) from #{table_name}" )
-    if rows_s
-      return rows_s.to_i()
-    else
-      return nil
-    end
-  end
-
-  ####
-  # make a temporary table: make a table in a new, temporary file
-  #
-  # returns: DBWrapper object (or object of current subclass)
-  # that has the @table_name attribute set to the name of a temporary DB
-  #
-  # same as in superclass
-  #
-  #   def make_temp_table(column_formats, # array: string*string [column_name,column_format]
-  #                       index_column_names, # array: string: column_name
-  #                       indexname)  # string: name of autoincrement primary index
-  
-  #     temp_obj = self.clone()
-  #     temp.initialize_temp_table(column_formats, index_column_names, indexname)
-  #     return temp_obj
-  #   end
-
-  def drop_temp_table()
-    @tf.close(true)
-    @database = nil
-  end
-
-  ##############################
-  protected
-
-  def initialize_temp_table(column_formats, index_column_names, indexname)
-    @table_name = "temptable"
-    @tf = Tempfile.new("temp_table")
-    @tf.close()
-    @database = SQLite3::Database.new(@tf.path())
-    create_table(@table_name, column_formats, index_column_names, indexname)
-  end
-
-end

data/lib/db/db_table.rb

@@ -1,239 +0,0 @@
-# class DBTable
-# KE, SP 27.1.05
-#
-# Manages one table in a (given) SQL database
-# Doesn't know anything about the ROSY application
-# Just creating a table, changing the table, and accessing it.
-#
-
-require 'db/sql_query'
-require "common/RosyConventions"
-
-class DBTable
-  attr_reader :index_name, :table_name
-
-  #####
-  # new
-  #
-  # creates the table for this object.
-  # The name of the table (given as parameter) can be new, in which caes the table
-  # is created, or old, in which case we check whether its format matches the format
-  # given in the parameters.
-  #
-  # The table format is given in the form of column formats (column names and column formats,
-  # formats are the usual SQLy things). Additionally, a subset of the column names can be
-  # designated index columns, which means that the table is indexed (and can be searched quickly)
-  # for them.
-  #
-  # DBTable internally constructs a "Primary index" feature that is called "XXindexXX" (autoincrement column)
-  #
-  # For all columns that are added later using add_columns, DBTable adds a prefix to the column names;
-  # these columns are not checked against the column_formats when opening an existing table;
-  # this can be used to store experiment-specific data.
-
-  def initialize(db_obj, # DBWrapper object
-		 table_name, # string: name of DB table (existing/new)
-		 mode,       # new: starts new DB table, removes old if it exists. open: reopens existing DB table
-		 hash={})    # hash: parameter name => parameter value, depending on mode
-                             # mode= new needs: 
-                             #  'col_formats': array:array len 2: string*string, [column_name, column_format] 
-                             #  'index_cols':  array:string: column_names that should be used to index the table
-                             #  'addcol_prefix': string: prefix for names of additional columns
-                             # mode='open' needs:
-                             #  'col_formats': array: string*string: column names/formats
-                             #               May be nil, in that case column name match isn't tested
-
-    @index_name = "XXindexXX"
-    @db_obj = db_obj
-    @table_name = table_name
-
-    case mode
-    when 'new'
-      ###
-      # open new database
-
-      # sanity check: exactly the required parameters present?
-      unless hash.keys.sort == ['addcol_prefix', 'col_formats', 'index_cols']
-	raise "Expecting hash parameters 'addcol_prefix', 'col_formats', 'index_cols'.\n" +
-	  "I got: " + hash.keys.join(", ")
-      end
-
-      # sanity check: main index column name should be unique
-      all_column_names = hash['col_formats'].map { |name, format| name}
-      if all_column_names.include? @index_name
-	raise "[DBTable] You used the reserved name #{@index_name} as a column name. Please don't do that!"
-      end
-
-      # sanity check: index_column_names should be included in column_names
-      hash['index_cols'].each { |name| 
-	unless all_column_names.include? name
-	  raise "[DBTable] #{name} is in the list of index names, but it isn't in the list of column names."
-	end
-      }
-
-      # does a table with name table_name exist? if so, remove it
-      if @db_obj.list_tables().include? table_name
-	# this table exists
-	# remove old table
-	@db_obj.drop_table(table_name)
-      end
-
-      @db_obj.create_table(table_name,hash['col_formats'],
-                           hash['index_cols'], @index_name)
-    when 'open'
-
-      ###
-      # open existing database table
-
-      # sanity check: exactly the required parameters present?
-      hash.keys.each { |key|
-        unless ['addcol_prefix', 'col_names'].include? key
-          raise "Expecting hash parameters 'addcol_prefix', 'col_names'.\n" +
-          "I got: " + hash.keys.join(", ")
-        end
-      }
-      # sanity check: main index column name should be unique
-      if hash['col_names'] and hash['col_names'].include? @index_name
-	raise "[DBTable] You used the reserved name #{@index_name} as a column name. Please don't do that!"
-      end
-
-
-      # does a table with name table_name exist?
-      unless @db_obj.list_tables().include? table_name
-	raise "[DBTable] Sorry, I cannot find a database table named #{table_name}."
-      end
-
-      # check if all column formats match
-
-      if hash['col_names']
-
-        existing_fields = @db_obj.list_column_names(table_name).reject { |col|
-          col =~ /^#{hash["addcol_prefix"]}/ or
-          col == @index_name
-        }
-
-        unless existing_fields.sort() == hash["col_names"].sort()
-          raise "[DBTable] Column names in the DB table #{table_name}\n" + 
-                "don't match feature specification in the experiment file.\n" + 
-                "Table:\n\t" + existing_fields.sort.join(", ") +
-                 "\n\nExp. file:\n\t" + hash["col_names"].sort.join(", ")
-        end
-
-      else
-        # no column names given, no check of column formats
-      end
-
-    else
-      raise "Parameter 'mode' needs to be either 'new' or 'open'! I got " + mode.to_s
-    end
-  end
-
-  #####
-  # list_column_names
-  #
-  # list column names of this table
-  #
-  # returns: array:string, list of column names
-  def list_column_names()
-    return @db_obj.list_column_names(@table_name)
-  end
-
-  #####
-  # list_column_formats
-  #
-  # list column names and column types of this table
-  #
-  # returns: array:string*string, list of pairs [column name, column format]
-  def list_column_formats()
-    return @db_obj.list_column_formats(@table_name)
-  end
-
-  #####
-  # change_format_add_columns
-  #
-  # adds one or more columns to the table managed by this object
-  # columns are given by their names and formats, as above
-  #
-  # returns: nothing
-  def change_format_add_columns(column_formats) # array: string*string [column_name,column_format]
-
-    if column_formats.nil? or column_formats.empty?
-      raise "Need nonempty column_formats list"
-    end
-    
-    column_formats.each {|col_name,col_format|
-      unless col_name =~ /^#{@addcol_prefix}/
-	raise "Columns that are added need to have prefix #{@addcol_prefix}!" 
-      end
-    }
-
-    execute_command(SQLQuery.add_columns(@table_name, column_formats))
-  end
-
-  #####
-  # change_format_remove_column
-  #
-  # removes one column from the table managed by this object
-  #
-  # returns: nothing
-  def change_format_remove_column(column_name) # string:name of the column to remove
-    unless list_column_names(@table_name).include? column_name
-      $stderr.puts "WARNING: Cannot remove column #{column_name}: I don't have it"
-      return
-    end
-
-    execute_command("ALTER TABLE #{@table_name} DROP COLUMN #{column_name}")
-  end
-
-  
-  #####
-  # insert_row
-  #
-  # inserts a new row into the table and fills cells with values, as specified
-  # by the column_value_pairs
-  #
-  # returns: nothing
-  def insert_row(column_value_pairs) # array: string*Object [column_name,column_value]
-    if column_value_pairs.nil? or column_value_pairs.empty?
-      raise "Need nonempty column_value_pairs list"
-    end
-    execute_command(SQLQuery.insert(@table_name,column_value_pairs))
-  end
-
-  #####
-  # update_row
-  #
-  # update column values for a given row which is identified
-  # via its (autoincrement) index
-  #
-  # returns: nothing
-  def update_row(index, # index, content of autoincrement column
-		 column_value_pairs) # array: string*Object [column_name, column_value]
-
-    if column_value_pairs.nil? or column_value_pairs.empty?
-      raise "Need nonempty column_value_pairs list"
-    end
-    execute_command(SQLQuery.update(@table_name,
-				    column_value_pairs, 
-				    [ValueRestriction.new(@index_name, index)]))
-  end
-
-
-  ####
-  private
-
-  ###
-  # execute_command:
-  # execute DB command
-  #
-  # returns nil: the commands in this package are all
-  # not of the kind that requires a return value
-  def execute_command(command)
-    begin
-      @db_obj.query_noretv(command)
-    rescue 
-      $stderr.puts "Error executing SQL query. Command was:\n" + command
-      exit 1
-    end
-  end
-end