rdf_context 0.4.2

data/lib/rdf_context/store/sqlite3_store.rb

@@ -0,0 +1,223 @@
+require 'sqlite3'
+require File.join(File.dirname(__FILE__), 'abstract_sql_store')
+
+module RdfContext
+  # SQLite3 store context-ware and formula-aware implementation.
+  # It stores it's triples in the following partitions:
+  # - Asserted non rdf:type statements
+  # - Asserted rdf:type statements (in a table which models Class membership). The motivation for this partition is primarily query speed and scalability as most graphs will always have more rdf:type statements than others
+  # - All Quoted statements
+  #
+  #  In addition it persists namespace mappings in a seperate table
+  #
+  # Based on Python RdfLib SQLite
+  class SQLite3Store < AbstractSQLStore
+    def initialize(identifier = nil, configuration = {})
+      super(identifier, configuration)
+
+      @autocommit_default = false
+      @path = configuration[:path] || File.join(Dir.getwd, "#{@internedId}.db")
+      @db = open(:path => @path) unless @db
+    end
+    
+    # Opens the store specified by the configuration hash. If
+    # create is True a store will be created if it does not already
+    # exist. If create is False and a store does not already exist
+    # an exception is raised. An exception is also raised if a store
+    # exists, but there is insufficient permissions to open the
+    # store.
+    #
+    # @param(Hash) options: Configuration hash
+    # <em>_path_:: Path to database file defaults to a file in the current directory based on a hash of the store identifier
+    def open(options)
+      unless File.exist?(options[:path])
+        @db = SQLite3::Database.new(options[:path])
+        executeSQL(CREATE_ASSERTED_STATEMENTS_TABLE % @internedId)
+        executeSQL(CREATE_ASSERTED_TYPE_STATEMENTS_TABLE % @internedId)
+        executeSQL(CREATE_QUOTED_STATEMENTS_TABLE % @internedId)
+        executeSQL(CREATE_NS_BINDS_TABLE % @internedId)
+        executeSQL(CREATE_LITERAL_STATEMENTS_TABLE % @internedId)
+        
+        # Create indicies
+        {
+          asserted_table => {
+            "#{@internedId}_A_termComb_index" => %w(termComb),
+            "#{@internedId}_A_s_index" => %w(subject),
+            "#{@internedId}_A_p_index" => %w(predicate),
+            "#{@internedId}_A_o_index" => %w(object),
+            "#{@internedId}_A_c_index" => %w(context),
+          },
+          asserted_type_table => {
+            "#{@internedId}_T_termComb_index" => %w(termComb),
+            "#{@internedId}_T_member_index" => %w(member),
+            "#{@internedId}_T_klass_index" => %w(klass),
+            "#{@internedId}_T_c_index" => %w(context),
+          },
+          literal_table => {
+            "#{@internedId}_L_termComb_index" => %w(termComb),
+            "#{@internedId}_L_s_index" => %w(subject),
+            "#{@internedId}_L_p_index" => %w(predicate),
+            "#{@internedId}_L_c_index" => %w(context),
+          },
+          quoted_table => {
+            "#{@internedId}_Q_termComb_index" => %w(termComb),
+            "#{@internedId}_Q_s_index" => %w(subject),
+            "#{@internedId}_Q_p_index" => %w(predicate),
+            "#{@internedId}_Q_o_index" => %w(object),
+            "#{@internedId}_Q_c_index" => %w(context),
+          },
+          namespace_binds => {
+            "#{@internedId}_uri_index" => %w(uri),
+          }
+        }.each_pair do |tablename, indicies|
+          indicies.each_pair do |index, columns|
+            executeSQL("CREATE INDEX #{index} on #{tablename} ('#{columns.join(', ')}')")
+          end
+        end
+      end
+
+      raise StoreException.new("Attempt to open missing database file #{options[:path]}") unless File.exist?(options[:path])
+      @db = SQLite3::Database.new(options[:path])
+    end
+
+    # Destroy databse
+    #
+    # @param(Hash) options: Configuration hash
+    # <em>_path_:: Path to database file
+    def destroy(options = {})
+      File.delete(@path)
+    end
+
+    protected
+
+    # Escape backslashes and single quotes
+    def escapeQuotes(qstr)
+      qstr.nil? ? "" : qstr.gsub("\\","\\\\").gsub("'", "\\'").gsub('"', '""')
+    end
+
+    # Where clase utility functions
+    def buildSubjClause(subject, tableName)
+  #    case subject
+  #    when REGEXTerm
+  #    when Array
+  #    when QuotedGraph
+  #    else
+        ["#{tableName}.subject=?", subject] if subject
+  #    end
+    end
+
+    def buildPredClause(predicate, tableName)
+  #    case predicate
+  #    when REGEXTerm
+  #    when Array
+  #    else
+        ["#{tableName}.predicate=?", predicate] if predicate
+  #    end
+    end
+
+    # Where clase utility functions
+    def buildObjClause(object, tableName)
+  #    case object
+  #    when REGEXTerm
+  #    when Array
+  #    when QuotedGraph
+  #    else
+        ["#{tableName}.object=?", object] if object
+  #    end
+    end
+
+    # Where clase utility functions
+    def buildContextClause(context, tableName)
+      context = normalizeTerm(context) if context
+
+  #    case context
+  #    when REGEXTerm
+  #    when Array
+  #    else
+        ["#{tableName}.context=?", context] if context
+  #    end
+    end
+
+    # Where clase utility functions
+    def buildTypeMemberClause(subject, tableName)
+  #    case context
+  #    when REGEXTerm
+  #    when Array
+  #    else
+        ["#{tableName}.member=?", subject] if subject
+  #    end
+    end
+
+    # Where clase utility functions
+    def buildTypeClassClause(object, tableName)
+  #    case context
+  #    when REGEXTerm
+  #    else
+        ["#{tableName}.klass=?", object] if object
+  #    end
+    end
+
+    # This takes the query string and parameters and (depending on the SQL implementation) either fill in
+    # the parameter in-place or pass it on to the DB impl (if it supports this).
+    # The default (here) is to fill the parameters in-place surrounding each param with quote characters
+    #
+    # Yields each row
+    def executeSQL(qStr, *params, &block)
+      @statement_cache ||= {}
+      #@statement_cache[qStr] ||= @db.prepare(qStr)
+      @statement_cache[qStr] ||= qStr
+
+      puts "executeSQL: '#{qStr}', #{params.join(", ")}" if $DEBUG
+      if block_given?
+        @db.execute(@statement_cache[qStr], *params) do |row|
+          puts "executeSQL res: #{row.inspect}" if $DEBUG
+          yield(row)
+        end
+      else
+        @db.execute(@statement_cache[qStr], *params)
+      end
+    end
+
+    CREATE_ASSERTED_STATEMENTS_TABLE = %(
+    CREATE TABLE %s_asserted_statements (
+        subject       text not NULL,
+        predicate     text not NULL,
+        object        text not NULL,
+        context       text not NULL,
+        termComb      tinyint unsigned not NULL))
+
+    CREATE_ASSERTED_TYPE_STATEMENTS_TABLE = %(
+    CREATE TABLE %s_type_statements (
+        member        text not NULL,
+        klass         text not NULL,
+        context       text not NULL,
+        termComb      tinyint unsigned not NULL))
+
+    CREATE_LITERAL_STATEMENTS_TABLE = %(
+    CREATE TABLE %s_literal_statements (
+        subject       text not NULL,
+        predicate     text not NULL,
+        object        text,
+        context       text not NULL,
+        termComb      tinyint unsigned not NULL,
+        objLanguage   varchar(3),
+        objDatatype   text))
+
+    CREATE_QUOTED_STATEMENTS_TABLE = %(
+    CREATE TABLE %s_quoted_statements (
+        subject       text not NULL,
+        predicate     text not NULL,
+        object        text,
+        context       text not NULL,
+        termComb      tinyint unsigned not NULL,
+        objLanguage   varchar(3),
+        objDatatype   text))
+
+    CREATE_NS_BINDS_TABLE = %(
+    CREATE TABLE %s_namespace_binds (
+        prefix        varchar(20) UNIQUE not NULL,
+        uri           text,
+        PRIMARY KEY (prefix)))
+
+  end
+end

data/lib/rdf_context/string_hacks.rb

@@ -0,0 +1,108 @@
+require 'iconv'
+
+class String
+  #private
+  # "Borrowed" from JSON utf8_to_json
+  RDF_MAP = {
+    "\x0" => '\u0000',
+    "\x1" => '\u0001',
+    "\x2" => '\u0002',
+    "\x3" => '\u0003',
+    "\x4" => '\u0004',
+    "\x5" => '\u0005',
+    "\x6" => '\u0006',
+    "\x7" => '\u0007',
+    "\b"  =>  '\b',
+    "\t"  =>  '\t',
+    "\n"  =>  '\n',
+    "\xb" => '\u000B',
+    "\f"  =>  '\f',
+    "\r"  =>  '\r',
+    "\xe" => '\u000E',
+    "\xf" => '\u000F',
+    "\x10" => '\u0010',
+    "\x11" => '\u0011',
+    "\x12" => '\u0012',
+    "\x13" => '\u0013',
+    "\x14" => '\u0014',
+    "\x15" => '\u0015',
+    "\x16" => '\u0016',
+    "\x17" => '\u0017',
+    "\x18" => '\u0018',
+    "\x19" => '\u0019',
+    "\x1a" => '\u001A',
+    "\x1b" => '\u001B',
+    "\x1c" => '\u001C',
+    "\x1d" => '\u001D',
+    "\x1e" => '\u001E',
+    "\x1f" => '\u001F',
+    '"'   =>  '\"',
+    '\\'  =>  '\\\\',
+    '/'   =>  '/',
+  } # :nodoc:
+
+  # Convert a UTF8 encoded Ruby string _string_ to an escaped string, encoded with
+  # UTF16 big endian characters as \U????, and return it.
+  #
+  # \\:: Backslash
+  # \':: Single quote
+  # \":: Double quot
+  # \n:: ASCII Linefeed
+  # \r:: ASCII Carriage Return
+  # \t:: ASCCII Horizontal Tab
+  # \uhhhh:: character in BMP with Unicode value U+hhhh
+  # \U00hhhhhh:: character in plane 1-16 with Unicode value U+hhhhhh
+  def rdf_escape
+    string = self + '' # XXX workaround: avoid buffer sharing
+    string.force_encoding(Encoding::ASCII_8BIT) if String.method_defined?(:force_encoding)
+    string.gsub!(/["\\\/\x0-\x1f]/) { RDF_MAP[$&] }
+    string.gsub!(/(
+                    (?:
+                      [\xc2-\xdf][\x80-\xbf]    |
+                      [\xe0-\xef][\x80-\xbf]{2} |
+                      [\xf0-\xf4][\x80-\xbf]{3}
+                    )+ |
+                    [\x80-\xc1\xf5-\xff]       # invalid
+                  )/nx) { |c|
+                    c.size == 1 and raise TypeError, "invalid utf8 byte: '#{c}'"
+                    s = Iconv.new('utf-16be', 'utf-8').iconv(c).unpack('H*')[0].upcase
+                    s.gsub!(/.{4}/n, '\\\\u\&')
+                  }
+    string.force_encoding(Encoding::UTF_8) if String.method_defined?(:force_encoding)
+    string
+  end
+  
+  # Unescape characters in strings.
+  RDF_UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
+  RDF_UNESCAPE_MAP.update({
+    ?"  => '"',
+    ?\\ => '\\',
+    ?/  => '/',
+    ?b  => "\b",
+    ?f  => "\f",
+    ?n  => "\n",
+    ?r  => "\r",
+    ?t  => "\t",
+    ?u  => nil, 
+  })
+
+  # Reverse operation of escape
+  # From JSON parser
+  def rdf_unescape
+    return '' if self.empty?
+    string = self.gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) do |c|
+      if u = RDF_UNESCAPE_MAP[$&[1]]
+        u
+      else # \uXXXX
+        bytes = [c[2, 2].to_i(16), c[4, 2].to_i(16)]
+        Iconv.new('utf-8', 'utf-16').iconv(bytes.pack("C*"))
+      end
+    end
+    if string.respond_to?(:force_encoding)
+      string.force_encoding(Encoding::UTF_8)
+    end
+    string
+  rescue Iconv::Failure => e
+    raise RdfException, "Caught #{e.class}: #{e}"
+  end
+end

data/lib/rdf_context/term_utils.rb

@@ -0,0 +1,196 @@
+require File.join(File.dirname(__FILE__), 'uriref')
+
+module RdfContext
+  module TermUtils
+    TERM_INSTANTIATION_DICT = {
+        'U' => URIRef,
+        'B' => BNode,
+        #'V' => Variable,
+        'L' => Literal
+    }
+
+    GRAPH_TERM_DICT = {
+        #'F' => [QuotedGraph, URIRef],
+        'U' => [Graph, URIRef],
+        'B' => [Graph, BNode]
+    }
+
+    SUBJECT = 0
+    PREDICATE = 1
+    OBJECT = 2
+    CONTEXT = 3
+
+    TERM_COMBINATIONS = {
+        'UUUU' => 0,
+        'UUUB' => 1,
+        'UUUF' => 2,
+        'UUVU' => 3,
+        'UUVB' => 4,
+        'UUVF' => 5,
+        'UUBU' => 6,
+        'UUBB' => 7,
+        'UUBF' => 8,
+        'UULU' => 9,
+        'UULB' => 10,
+        'UULF' => 11,
+        'UUFU' => 12,
+        'UUFB' => 13,
+        'UUFF' => 14,
+
+        'UVUU' => 15,
+        'UVUB' => 16,
+        'UVUF' => 17,
+        'UVVU' => 18,
+        'UVVB' => 19,
+        'UVVF' => 20,
+        'UVBU' => 21,
+        'UVBB' => 22,
+        'UVBF' => 23,
+        'UVLU' => 24,
+        'UVLB' => 25,
+        'UVLF' => 26,
+        'UVFU' => 27,
+        'UVFB' => 28,
+        'UVFF' => 29,
+
+        'VUUU' => 30,
+        'VUUB' => 31,
+        'VUUF' => 33,
+        'VUVU' => 34,
+        'VUVB' => 35,
+        'VUVF' => 36,
+        'VUBU' => 37,
+        'VUBB' => 38,
+        'VUBF' => 39,
+        'VULU' => 40,
+        'VULB' => 41,
+        'VULF' => 42,
+        'VUFU' => 43,
+        'VUFB' => 44,
+        'VUFF' => 45,
+
+        'VVUU' => 46,
+        'VVUB' => 47,
+        'VVUF' => 48,
+        'VVVU' => 49,
+        'VVVB' => 50,
+        'VVVF' => 51,
+        'VVBU' => 52,
+        'VVBB' => 53,
+        'VVBF' => 54,
+        'VVLU' => 55,
+        'VVLB' => 56,
+        'VVLF' => 57,
+        'VVFU' => 58,
+        'VVFB' => 59,
+        'VVFF' => 60,
+
+        'BUUU' => 61,
+        'BUUB' => 62,
+        'BUUF' => 63,
+        'BUVU' => 64,
+        'BUVB' => 65,
+        'BUVF' => 66,
+        'BUBU' => 67,
+        'BUBB' => 68,
+        'BUBF' => 69,
+        'BULU' => 70,
+        'BULB' => 71,
+        'BULF' => 72,
+        'BUFU' => 73,
+        'BUFB' => 74,
+        'BUFF' => 75,
+
+        'BVUU' => 76,
+        'BVUB' => 77,
+        'BVUF' => 78,
+        'BVVU' => 79,
+        'BVVB' => 80,
+        'BVVF' => 81,
+        'BVBU' => 82,
+        'BVBB' => 83,
+        'BVBF' => 84,
+        'BVLU' => 85,
+        'BVLB' => 86,
+        'BVLF' => 87,
+        'BVFU' => 88,
+        'BVFB' => 89,
+        'BVFF' => 90,
+
+        'FUUU' => 91,
+        'FUUB' => 92,
+        'FUUF' => 93,
+        'FUVU' => 94,
+        'FUVB' => 95,
+        'FUVF' => 96,
+        'FUBU' => 97,
+        'FUBB' => 98,
+        'FUBF' => 99,
+        'FULU' => 100,
+        'FULB' => 101,
+        'FULF' => 102,
+        'FUFU' => 103,
+        'FUFB' => 104,
+        'FUFF' => 105,
+
+        'FVUU' => 106,
+        'FVUB' => 107,
+        'FVUF' => 108,
+        'FVVU' => 109,
+        'FVVB' => 110,
+        'FVVF' => 111,
+        'FVBU' => 112,
+        'FVBB' => 113,
+        'FVBF' => 114,
+        'FVLU' => 115,
+        'FVLB' => 116,
+        'FVLF' => 117,
+        'FVFU' => 118,
+        'FVFB' => 119,
+        'FVFF' => 120,
+    }
+
+    REVERSE_TERM_COMBINATIONS = TERM_COMBINATIONS.invert
+
+    # Takes an instance of a Graph (Graph, QuotedGraph, ConjunctiveGraph)
+    # and returns the Graphs identifier and 'type' ('U' for Graphs, 'F' for QuotedGraphs ).
+    def normalizeGraph(graph)
+      t = #graph.is_a?(QuotedGraph) ? "F" : term2Letter(graph.identifier)
+      identifier = graph.respond_to?(:identifier) ? graph.identifier : graph
+      t = term2Letter(identifier)
+      [identifier, t]
+    end
+    
+    def term2Letter(term)
+      case term
+      when URIRef       then "U"
+      when BNode        then "B"
+      when Literal      then "L"
+      #when QuotedGraph  then "F"
+      #when Variable     then "V"
+      when Graph        then term2Letter(term.identifier)
+      when nil          then "L"
+      else
+        raise RdfException.new("The given term (#{term}) is not an instance of any of the known types (URIRef, BNode, Literal, QuotedGraph, or Graph).  It is a #{term.class}")
+      end
+    end
+    
+    def constructGraph(term)
+      GRAPH_TERM_DICT[term]
+    end
+    
+    def type2TermCombination(member,klass,context)
+      key = "#{term2Letter(member)}U#{term2Letter(klass)}#{normalizeGraph(context)[1]}"
+      TERM_COMBINATIONS.fetch(key)
+    rescue IndexError
+       raise RdfException.new("Unable to persist classification triple: #{member.inspect}, rdf:type, #{klass.inspect}, context: #{context.inspect}, key: #{key}")
+    end
+    
+    def statement2TermCombination(triple,context)
+      key = "#{term2Letter(triple.subject)}#{term2Letter(triple.predicate)}#{term2Letter(triple.object)}#{normalizeGraph(context)[1]}"
+      TERM_COMBINATIONS.fetch(key)
+    rescue IndexError
+      raise RdfException.new("Unable to persist triple: #{triple.inspect}, context: #{context.inspect}, key: #{key}")
+    end
+  end
+end