libsql 0.1.0-x64-mingw-ucrt

data/examples/fts5.rb

@@ -0,0 +1,152 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'libsql'
+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 #{::Libsql::VERSION})"
+db = ::Libsql::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

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+#
+# Basic libsql example creating a table, inserting rows and doing various
+# selects and prepared statements
+#
+require 'rubygems'
+require 'libsql'
+
+#
+# Create a database, this will create the DB if it doesn't exist
+#
+puts "Opening database (version #{::Libsql::Version})"
+db = ::Libsql::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   = ::Libsql::Taps::IO.new( trace_tap_file = File.open("trace_tap.log", "w+") )
+db.profile_tap = ::Libsql::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/schema-info.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'libsql'
+
+db_name = ARGV.shift
+unless db_name 
+  puts "Usage: #{File.basename($0)} dbname" 
+  exit 1
+end
+db = ::Libsql::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
+

data/ext/libsql/c/extconf.rb

@@ -0,0 +1,86 @@
+require 'mkmf'
+require 'rbconfig'
+
+# used by the ext:build_win-1.x.x tasks, really no one else but jeremy should be
+# using this hack
+$ruby = ARGV.shift if ARGV[0]
+
+# make available table and column meta data api
+$CFLAGS += " -DSQLITE_ENABLE_BYTECODE_VTAB=1"
+$CFLAGS += " -DSQLITE_ENABLE_COLUMN_METADATA=1"
+$CFLAGS += " -DSQLITE_ENABLE_DBSTAT_VTAB=1"
+$CFLAGS += " -DSQLITE_ENABLE_DBPAGE_VTAB=1"
+$CFLAGS += " -DSQLITE_ENABLE_EXPLAIN_COMMENTS=1"
+$CFLAGS += " -DSQLITE_ENABLE_FTS3=1"
+$CFLAGS += " -DSQLITE_ENABLE_FTS3_PARENTHESIS=1"
+$CFLAGS += " -DSQLITE_ENABLE_FTS4=1"
+$CFLAGS += " -DSQLITE_ENABLE_FTS5=1"
+$CFLAGS += " -DSQLITE_ENABLE_GEOPOLY=1"
+$CFLAGS += " -DSQLITE_ENABLE_MATH_FUNCTIONS=1"
+$CFLAGS += " -DSQLITE_ENABLE_MEMORY_MANAGEMENT=1"
+$CFLAGS += " -DSQLITE_ENABLE_NORMALIZE=1"
+$CFLAGS += " -DSQLITE_ENABLE_NULL_TRIM=1"
+$CFLAGS += " -DSQLITE_ENABLE_PREUPDATE_HOOK=1"
+$CFLAGS ++ " -DSQLITE_EANBLE_QPSG=1"
+$CFLAGS += " -DSQLITE_ENABLE_RBU=1"
+$CFLAGS += " -DSQLITE_ENABLE_RTREE=1"
+$CFLAGS += " -DSQLITE_ENABLE_SESSION=1"
+# https://github.com/libsql/libsql/issues/144
+# $CFLAGS += " -DSQLITE_ENABLE_SNAPSHOT=1"
+$CFLAGS += " -DSQLITE_ENABLE_STMTVTAB=1"
+$CFLAGS += " -DSQLITE_ENABLE_STAT4=1"
+$CFLAGS += " -DSQLITE_ENABLE_UNLOCK_NOTIFY=1"
+$CFLAGS += " -DSQLITE_ENABLE_SOUNDEX=1"
+
+$CFLAGS += " -DSQLITE_USE_ALLOCA=1"
+$CFLAGS += " -DSQLITE_OMIT_DEPRECATED=1"
+
+# we compile sqlite the same way that the installation of ruby is compiled.
+if RbConfig::MAKEFILE_CONFIG['configure_args'].include?( "--enable-pthread" ) then
+  $CFLAGS += " -DSQLITE_THREADSAFE=1"
+else
+  $CFLAGS += " -DSQLITE_THREADSAFE=0"
+end
+
+# remove the -g flags  if it exists
+%w[ -ggdb\\d* -g\\d* ].each do |debug|
+  $CFLAGS = $CFLAGS.gsub(/\s#{debug}\b/,'')
+  RbConfig::MAKEFILE_CONFIG['debugflags'] = RbConfig::MAKEFILE_CONFIG['debugflags'].gsub(/\s#{debug}\b/,'')   if RbConfig::MAKEFILE_CONFIG['debugflags']
+end
+
+ignoreable_warnings = %w[ write-strings ]
+ignore_by_compiler = {
+  "clang" => %w[
+                  empty-body
+                  declaration-after-statement
+                  incompatible-pointer-types-discards-qualifiers
+                  shorten-64-to-32
+                  sign-compare
+                  unused-const-variable
+                  unused-variable
+                  unused-but-set-variable
+                  undef
+  ],
+  "gcc" => %w[
+              declaration-after-statement
+              implicit-function-declaration
+              unused-variable
+              unused-but-set-variable
+              maybe-uninitialized
+              old-style-definition
+              undef
+  ]
+}
+
+if extras = ignore_by_compiler[RbConfig::MAKEFILE_CONFIG["CC"]] then
+  ignoreable_warnings.concat(extras)
+end
+
+ignoreable_warnings.each do |warning|
+  $CFLAGS = $CFLAGS.gsub(/-W#{warning}/,'')
+  RbConfig::MAKEFILE_CONFIG['warnflags'] = RbConfig::MAKEFILE_CONFIG['warnflags'].gsub(/-W#{warning}/,'') if RbConfig::MAKEFILE_CONFIG['warnflags']
+  $CFLAGS += " -Wno-#{warning}"
+end
+
+subdir = RUBY_VERSION.sub(/\.\d$/,'')
+create_makefile("libsql/#{subdir}/libsql_ext")