amalgalite 1.9.4-x86-mingw32 → 2.0.0-x86-mingw32

data/examples/define_aggregate.rb

@@ -1,75 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-$: << "../lib"
-$: << "../ext"
-require 'amalgalite'
-
-#--
-# Create a database and a table to put some results from the functions in
-#--
-db = Amalgalite::Database.new( ":memory:" )
-db.execute( "CREATE TABLE atest( words )" )
-
-#------------------------------------------------------------------------------
-# Create unique word count aggregate 
-#------------------------------------------------------------------------------
-class UniqueWordCount < ::Amalgalite::Aggregate
-  attr_accessor :words
-
-  def initialize
-    @name = 'unique_word_count'
-    @arity = 1
-    @words = Hash.new { |h,k| h[k] = 0 }
-  end
-
-  def step( str )
-    str.split(/\W+/).each do |word|
-      words[ word.downcase ] += 1
-    end
-    return nil
-  end
-
-  def finalize
-    return words.size
-  end
-end
-
-db.define_aggregate( 'unique_word_count', UniqueWordCount )
-
-#------------------------------------------------------------------------------
-# Now we have a new aggregate function, lets insert some rows into the database
-# and see what we can find.
-#------------------------------------------------------------------------------
-sql = "INSERT INTO atest( words ) VALUES( ? )"
-verify = {}
-db.prepare( sql ) do |stmt|
-  DATA.each do |words|
-    words.strip!
-    puts "Inserting #{words}"
-    stmt.execute( words )
-    words.split(/\W+/).each { |w| verify[w] = true }
-  end
-end
-
-#------------------------------------------------------------------------------
-# And show the results
-#------------------------------------------------------------------------------
-puts
-puts "Getting results..."
-puts
-all_rows = db.execute("SELECT unique_word_count( words ) AS uwc FROM atest")
-puts "#{all_rows.first['uwc']} unique words found"
-puts "#{verify.size} unique words to verify"
-
-__END__
-some random
-words with
-which
-to play
-and there should
-be a couple of different
-words that appear
-more than once and
-some that appear only
-once

data/examples/define_function.rb

@@ -1,104 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-$: << "../lib"
-$: << "../ext"
-require 'amalgalite'
-
-#--
-# Create a database and a table to put some results from the functions in
-#--
-db = Amalgalite::Database.new( ":memory:" )
-db.execute( "CREATE TABLE ftest( data, md5, sha1, sha2_bits, sha2)" )
-
-#------------------------------------------------------------------------------
-# Create an MD5 method using the block format of defining an sql fuction
-#------------------------------------------------------------------------------
-require 'digest/md5'
-db.define_function( 'md5' ) do |x|
-  Digest::MD5.hexdigest( x.to_s )
-end
-
-#------------------------------------------------------------------------------
-# Create a SHA1 method using the lambda format of defining an sql function
-#------------------------------------------------------------------------------
-require 'digest/sha1'
-sha1 = lambda do |y|
-  Digest::SHA1.hexdigest( y.to_s )
-end
-db.define_function( "sha1", sha1 )
-
-#------------------------------------------------------------------------------
-# Create a SHA2 method using the class format for defining an sql function
-# In this one we will allow any number of parameters, but we will only use the
-# first two.
-#------------------------------------------------------------------------------
-require 'digest/sha2'
-class SQLSha2
-  # track the number of invocations
-  attr_reader :call_count
-
-  def initialize
-    @call_count = 0
-  end
-
-  # the protocol that is used for sql function definition
-  def to_proc() self ; end
-
-  # say we take any number of parameters
-  def arity
-    -1
-  end
-
-  # The method that is called by SQLite, must be named 'call'
-  def call( *args )
-    text = args.shift.to_s
-    bitlength = (args.shift || 256).to_i
-    Digest::SHA2.new( bitlength ).hexdigest( text )
-  end
-end
-db.define_function('sha2', SQLSha2.new)
-
-
-#------------------------------------------------------------------------------
-# Now we have 3 new sql functions, each defined in one of the available methods
-# to define sql functions in amalgalite.  Lets insert some rows and look at the
-# results
-#------------------------------------------------------------------------------
-possible_bits = [ 256, 384, 512 ]
-sql = "INSERT INTO ftest( data, md5, sha1, sha2_bits, sha2 ) VALUES( @word , md5( @word ), sha1( @word ), @bits, sha2(@word,@bits) )" 
-db.prepare( sql ) do |stmt|
-  DATA.each do |word|
-    word.strip!
-    bits = possible_bits[ rand(3) ]
-    puts "Inserting #{word}, #{bits}"
-    stmt.execute( { '@word' => word, '@bits' => bits } )
-  end
-end
-
-#------------------------------------------------------------------------------
-# And show the results
-#------------------------------------------------------------------------------
-puts
-puts "Getting results..."
-puts
-columns = db.schema.tables['ftest'].columns.keys.sort
-i = 0
-db.execute("SELECT #{columns.join(',')} FROM ftest") do |row|
-  i += 1
-  puts "-----[ row #{i} ]-" + "-" * 42
-  columns.each do |col|
-    puts "#{col.ljust(10)} : #{row[col]}"
-  end
-  puts
-end
-
-
-__END__
-some
-random
-words
-with
-which
-to
-play

data/examples/fts5.rb

@@ -1,152 +0,0 @@
-#!/usr/bin/env ruby
-require 'rubygems'
-require 'amalgalite'
-require 'benchmark'
-require 'pathname'
-
-begin
-  require 'json'
-rescue LoadError 
-  abort "'gem install json' to run this example"
-end
-
-
-README = <<_
- This example program assumes that you have available the 'fortune' BSD command dataset.
-
- execute `fortune -f` to see if you have this command available.
-_
-
-fortune_dir = %x[ fortune -f 2>&1 ].split("\n").first.split.last
-abort README unless fortune_dir and File.directory?( fortune_dir )
-
-fortune_path = Pathname.new(fortune_dir)
-
-#
-# Lets create a database that utilizes FTS5 http://www.sqlite.org/fts5.html
-#
-#
-
-#
-# Create a database, this will create the DB if it doesn't exist
-#
-puts "Opening database (version #{Amalgalite::VERSION})"
-db = Amalgalite::Database.new("fts5.db")
-
-#
-# Create the schema unless it already exists in the table.  The meta information
-# about the database schema is available as the result of the db.schema method
-#
-schema = db.schema
-unless schema.tables['search'] 
-  puts "Create schema"
-  db.execute_batch <<-SQL
-  CREATE VIRTUAL TABLE search USING fts5(
-    filename,
-    content
-  );
-
-  CREATE TABLE plain (
-    filename VARCHAR(128),
-    content  TEXT 
-  );
-  SQL
-  db.reload_schema!
-end
-
-def each_fortune(path,&block)
-  fortune = []
-  path.each_line do |line|
-    line.strip!
-    if line == "%" then
-      yield fortune.join("\n")
-      fortune.clear
-    else 
-      fortune << line
-    end
-  end
-end
-
-#
-# Only load the data if the db is empty
-#
-if db.first_value_from( "SELECT count(*) from search" ) == 0 then
-  before = Time.now
-  idx = 0
-
-  # Inserting bulk rows as a transaction is good practice with SQLite, it is
-  # MUCH faster.  
-  db.transaction do |db_in_transaction|
-    # Iterate over the files in the fortunes dir and split on the fortunes, then 
-
-    fortune_path.each_child do |fortune_file|
-      next if fortune_file.directory?
-      next if fortune_file.extname == ".dat"
-      $stdout.puts "Loading #{fortune_file}"
-
-      each_fortune(fortune_file) do |fortune|
-        insert_data  = {
-          ':fname'   => fortune_file.to_s,
-          ':content' => fortune
-        }
-
-        # insert into the FTS5 table
-        db_in_transaction.prepare("INSERT INTO search( filename, content ) VALUES( :fname, :content );") do |stmt|
-          stmt.execute( insert_data )
-        end
-
-        # insert into the normal table for comparison
-        db_in_transaction.prepare("INSERT INTO plain( filename, content ) VALUES( :fname, :content );") do |stmt|
-          stmt.execute( insert_data )
-        end
-
-        idx += 1
-        print "Processed #{idx}\r"
-        $stdout.flush
-      end
-      puts "\nFinalizing..."
-    end
-  end
-  puts "Took #{Time.now - before} seconds to insert #{idx} fortunes"
-  puts "Done Inserting"
-end
-
-doc_count = db.first_value_from( "SELECT count(*) from search" ) 
-
-#
-# Now lets do some searching for some various words
-#
-
-%w[ president salmon thanks ].each do |word|
-
-  count = 100
-  puts
-  puts "Searching for '#{word}' #{count} times across #{doc_count} fortunes"
-  puts "=" * 60
-
-  Benchmark.bm( 15 ) do |x|
-
-    #
-    # search using the fts search to get the cont of tweets with the given word
-    #
-    x.report('fts5: ') do 
-      db.prepare( "SELECT count(filename) FROM search WHERE search MATCH 'content:#{word}'" ) do |stmt|
-        count.times do
-          stmt.execute
-        end
-      end
-    end
-
-    #
-    # search using basic string matching in sqlite.  
-    #
-    x.report('plain: ') do 
-      db.prepare( "SELECT count(filename) FROM plain WHERE content LIKE '% #{word} %'" ) do |stmt|
-        count.times do
-          stmt.execute
-        end
-      end
-    end
-  end
-end
-

data/examples/gem-db.rb

@@ -1,94 +0,0 @@
-#!/usr/bin/env ruby
-
-#
-# Basic amalgalite example creating a table, inserting rows and doing various
-# selects and prepared statements
-#
-require 'rubygems'
-require 'amalgalite'
-
-#
-# Create a database, this will create the DB if it doesn't exist
-#
-puts "Opening database (version #{Amalgalite::Version})"
-db = Amalgalite::Database.new("gems.db")
-
-#
-# Setup taps into profile and trace information of sqlite, the profile tap will
-# goto the profile_tap.log file and the trace information will go to the
-# trace_tap.log file
-#
-puts "Establishing taps"
-db.trace_tap   = Amalgalite::Taps::IO.new( trace_tap_file = File.open("trace_tap.log", "w+") )
-db.profile_tap = Amalgalite::Taps::IO.new( profile_tap_file = File.open("profile_tap.log", "w+") )
-
-#
-# Create the schema unless it already exists in the table.  The meta information
-# about the database schema is available as the result of the db.schema method
-#
-schema = db.schema
-unless schema.tables['gems'] 
-  puts "Create schema"
-  db.execute <<-SQL
-  CREATE TABLE gems (
-    id      INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-    name    VARCHAR(128),
-    version VARCHAR(32),
-    author  VARCHAR(128)
-  );
-  SQL
-  db.reload_schema!
-end
-
-#
-# Get some data from the system to insert into the database.  Since everyone
-# probably has gems installed, that's a ready known piece of information.  We'll
-# just pull in the latest version of each installed gem and dump some meta
-# information into a db for testing.
-#
-latest_specs = Gem.source_index.latest_specs
-
-puts "Inserting #{latest_specs.size} rows of gem information..."
-before = Time.now
-
-# Inserting bulk rows as a transaction is good practice with SQLite, it is
-# MUCH faster.  
-db.transaction do |db_in_transaction|
-  db_in_transaction.prepare("INSERT INTO gems(name, version, author) VALUES( :name, :version, :author );") do |stmt|
-    latest_specs.each do |spec|
-      insert_data = {}
-      insert_data[':name']    = spec.name.to_s
-      insert_data[':version'] = spec.version.to_s
-      insert_data[':author']  = spec.authors.join(' ')
-      #puts "Inserting #{insert_data.inspect}"
-      stmt.execute( insert_data )
-    end
-  end
-end
-puts "Took #{Time.now - before} seconds"
-puts "Done Inserting"
-
-authors_by_number = db.execute("SELECT author, count( name ) as num_gems FROM gems GROUP BY author ORDER BY num_gems DESC")
-favorite_author   = authors_by_number.first
-puts "Your favorite gem author is <#{favorite_author['author']}>, with #{favorite_author['num_gems']} gems installed."
-
-#
-# Now we'll look at the profile sampler and see what information it traced about
-# our behavoir.
-#
-db.profile_tap.samplers.each do |stat_name, stat_values|
-  puts "-" * 20
-  puts stat_values.to_s
-end
-
-#
-# Clear out the taps (not really necessary, just cleaning up)
-#
-db.trace_tap = profile_tap = nil
-
-#
-# close things down
-#
-db.close
-trace_tap_file.close
-profile_tap_file.close

data/examples/require_me.rb

@@ -1,11 +0,0 @@
-CONSTANT = "bad"
-class RequireMe
-  def initialize( msg )
-    @msg = msg
-    puts "RequireMe initialized"
-  end
-
-  def foo
-    puts @msg
-  end
-end

data/examples/requires.rb

@@ -1,42 +0,0 @@
-#!/usr/bin/env ruby
-
-#
-# An Amalgalite example showing how to 'require' data in an amalgalite database
-#
-# We'll make a database with one table, that we store file contents in.
-#
-
-$: << "../lib"
-$: << "../ext"
-require 'rubygems'
-require 'amalgalite'
-
-style = ARGV.shift || "normal"
-
-#
-# create the database 
-#
-dbfile = Amalgalite::Requires::Bootstrap::DEFAULT_DB
-File.unlink( dbfile ) if File.exist?( dbfile )
-require 'amalgalite/packer'
-options = { :verbose => true }
-if style == "compressed" then
-  options[:compressed] = true
-end
-p = Amalgalite::Packer.new( options )
-p.pack( [ "require_me.rb" ] )
-
-require 'amalgalite/requires'
-begin 
-  Amalgalite::Requires.new( :dbfile_name => p.dbfile )
-  FileUtils.mv 'require_me.rb', 'rm.rb', :verbose => true
-  require 'require_me'
-  e = RequireMe.new( "#{style} require style works!" )
-  e.foo
-  require 'require_me'
-  puts 
-
-ensure
-  FileUtils.mv 'rm.rb', 'require_me.rb', :verbose => true
-  File.unlink( dbfile ) if File.exist?( dbfile )
-end

data/examples/schema-info.rb

@@ -1,34 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require 'amalgalite'
-
-db_name = ARGV.shift
-unless db_name 
-  puts "Usage: #{File.basename($0)} dbname" 
-  exit 1
-end
-db = Amalgalite::Database.new( db_name )
-col_info = %w[ default_value declared_data_type collation_sequence_name not_null_constraint primary_key auto_increment ]
-max_width = col_info.collect { |c| c.length }.sort.last
-
-db.schema.tables.keys.sort.each do |table_name|
-  puts "Table: #{table_name}"
-  puts "=" * 42
-  db.schema.tables[table_name].columns.each_pair do |col_name, col|
-    puts "  Column : #{col.name}"
-    col_info.each do |ci|
-      puts "    |#{ci.rjust( max_width, "." )} : #{col.send( ci )}"
-    end
-    puts 
-  end
-
-  db.schema.tables[table_name].indexes.each_pair do |idx_name, index|
-    puts "  Index : #{index.name}"
-    puts "    |#{"sequence_number".rjust( max_width, "." )} : #{index.sequence_number}"
-    puts "    |#{"is unique?".rjust( max_width, ".")} : #{index.unique?}"
-    puts "    |#{"columns".rjust( max_width, ".")} : #{index.columns.collect { |c| c.name }.join(',') }"
-    puts
-  end
-end
-