Class: Oinky::Table

Inherits:
Object
  • Object
show all
Includes:
RowSet
Defined in:
lib/oinky.rb

Overview

module RowSet

Defined Under Namespace

Classes: Cursor

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from RowSet

#__each_filtered, #__make_filter_proc, #__rs_filter, #cursor_each, #each, #filter, #new_cursor

Constructor Details

#initialize(db, handle) ⇒ Table

Returns a new instance of Table.



781
782
783
784
 
# File 'lib/oinky.rb', line 781

def initialize(db, handle)
  @db, @handle = db, handle
  @table = self
end

Instance Attribute Details

#db ⇒ Object (readonly)

Returns the value of attribute db.



786
787
788
 
# File 'lib/oinky.rb', line 786

def db
  @db
end

Instance Method Details

#add_column(*a) ⇒ Object 



798
799
800
 
# File 'lib/oinky.rb', line 798

def add_column(*a)
  add_columns([a])
end

#add_columns(cset) ⇒ Object 



801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
 
# File 'lib/oinky.rb', line 801

def add_columns(cset)
  @db.atomic {
    if cset.is_a? Hash
      cset.each {|name,v|
        add_column_internal(v.merge(:name=>name))
      }
    else
      cset.each {|a|
        add_column_internal(a)
      }
    end
    # Refresh the default column selector
    reselect_all_columns
  }
  self
end

#add_index(opts) ⇒ Object

Raises:



836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
 
# File 'lib/oinky.rb', line 836

def add_index(opts)
  name = opts[:name]
  raise OinkyException.new("Invalid index name") unless name.length
  colset = (opts[:columns] or opts[:columnset])
  raise OinkyException.new("Oinky::Table::add_index: ':columns' not specified") unless colset
  raise OinkyException.new("Oinky::Table::add_index: ':unique' not specified") unless opts.has_key?(:unique)
  unique = opts[:unique]
  
  iptr = FFI::MemoryPointer.new :pointer
  colset = Internal::IndexColumnDefn.make_from_set(colset)
  Internal.wrap_oinky(Internal.oinky_table_add_index(
                                                     @handle, 
                                                     name, 
                                                     unique ? 1 : 0,
                                                     colset.count,
                                                     colset,
                                                     iptr))
  #return Index.new(iptr.read_pointer)
  #
  # It makes more sense that this should be like column than like
  # create_table
  self
end

#column_count ⇒ Object 



788
789
790
 
# File 'lib/oinky.rb', line 788

def column_count
  Internal.oinky_tbl_column_count(@handle)
end

#columns ⇒ Object 



866
867
868
869
870
871
872
873
874
875
876
877
878
879
 
# File 'lib/oinky.rb', line 866

def columns
  sz = self.column_count()
  defs = Internal::ColumnDefn::ColumnSet.new(sz)
  rsz = Internal.oinky_table_get_column_defs(@handle, defs, sz)
  unless rsz == sz
    raise OinkyException.new("Oinky: Unknown interface error - columncount [#{rsz}, #{sz}]") 
  end
  cols = ExHash.new
  (0..sz-1).each{|i|
    cd = defs[i]
    cols[cd[:column_name].to_s] = {:type=>cd[:column_type], :default =>cd[:default_value].rb_val}
  }
  cols
end

#delete_row(where) ⇒ Object

def update_row



983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
 
# File 'lib/oinky.rb', line 983

def delete_row(where)
  unless where.is_a? Internal::CursorBase
    raise OinkyException.new("Invalid row specifier.  Use a Cursor object.") 
  end
  p = nil
  if (where.is_a? Table::Cursor)
    p = Internal.method :oinky_table_delete_row_at_table_cursor
  else
    p = Internal.method :oinky_table_delete_row_at_index_cursor
  end
  Internal.wrap_oinky(
      p.call(
        @handle, 
        where.send(:eval,"@handle")))
  self
end

#drop_column(colname) ⇒ Object 



881
882
883
884
885
886
887
 
# File 'lib/oinky.rb', line 881

def drop_column(colname)
  dbs = Internal::DB_string.make(colname.to_s)
  Internal.wrap_oinky(Internal.oinky_table_drop_column(@handle, dbs))
  # Refresh the colset cache
  reselect_all_columns
  self
end

#drop_index(ixname) ⇒ Object 



938
939
940
941
942
 
# File 'lib/oinky.rb', line 938

def drop_index(ixname)
  dbs = Internal::DB_string.make(ixname.to_s)
  Internal.wrap_oinky(Internal.oinky_table_drop_index(@handle, dbs))
  self
end

#index_count ⇒ Object 



791
792
793
 
# File 'lib/oinky.rb', line 791

def index_count
  Internal.oinky_tbl_index_count(@handle)
end

#indices ⇒ Object 



923
924
925
926
927
928
929
930
931
932
933
934
935
936
 
# File 'lib/oinky.rb', line 923

def indices
  sz = self.index_count()
  handles = FFI::MemoryPointer.new(:pointer, sz)
  rsz = Internal.oinky_table_get_index_handles(@handle, handles, sz)
  unless rsz == sz
    raise OinkyException.new("Oinky: Unknown interface error - indexcount") 
  end
  r = ExHash.new
  (0..sz-1).each{|i| 
    ix = Index.new(self, handles[i].read_pointer)
    r[ix.name] = ix
  }
  return r
end

#insert_row(cs, values = nil) ⇒ Object

def delete_row



1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
 
# File 'lib/oinky.rb', line 1000

def insert_row(cs, values = nil)
  cs, count, vals = make_selector_and_values(:insert_row, cs, values)
  Internal.wrap_oinky(
      Internal.oinky_table_insert_row(
        @handle, 
        cs.handle, 
        count,
        vals))
  self
end

#name ⇒ Object 



860
861
862
863
864
 
# File 'lib/oinky.rb', line 860

def name
  return @tblname if @tblname
  dbs = Internal.oinky_table_name(@handle)
  @tblname = dbs.to_s
end

#reselect_all_columns ⇒ Object

Refreshes the selector cache



900
901
902
 
# File 'lib/oinky.rb', line 900

def reselect_all_columns
  @selectall = self.select_columns(self.columns.keys)
end

#row_count ⇒ Object 



794
795
796
 
# File 'lib/oinky.rb', line 794

def row_count
  Internal.oinky_tbl_row_count(@handle)
end

#select(cs) ⇒ Object 



904
905
906
907
908
909
910
911
912
 
# File 'lib/oinky.rb', line 904

def select(cs)
  cs = self.select_columns(cs)
  e = self.each(cs)
  if block_given?
    e.each {|k| yield k}
  else
    return e
  end
end

#select_all ⇒ Object 



914
915
916
917
918
919
920
921
 
# File 'lib/oinky.rb', line 914

def select_all
  e = self.select(self.select_all_columns)
  if block_given?
    e.each {|k| yield k}
  else
    return e
  end
end

#select_all_columns ⇒ Object

Caches the selector



896
897
898
 
# File 'lib/oinky.rb', line 896

def select_all_columns
  @selectall ||= self.reselect_all_columns
end

#select_columns(colnames) ⇒ Object 



889
890
891
892
893
 
# File 'lib/oinky.rb', line 889

def select_columns(colnames)
  return self.select_all_columns unless colnames
  return colnames if colnames.is_a? ColumnSelector
  ColumnSelector.new(self, colnames)
end

#update_row(where, cs, values = nil) ⇒ Object

class Cursor



962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
 
# File 'lib/oinky.rb', line 962

def update_row(where, cs, values = nil)
  unless where.is_a? Internal::CursorBase
    raise OinkyException.new("Invalid row specifier.  Use a Cursor object.") 
  end
  cs, count, vals = make_selector_and_values(:update_row, cs, values)
  p = nil
  if (where.is_a? Table::Cursor)
    p = Internal.method :oinky_table_update_row_at_table_cursor
  else
    p = Internal.method :oinky_table_update_row_at_index_cursor
  end
  Internal.wrap_oinky(
      p.call(
        @handle, 
        where.send(:eval,"@handle"), 
        cs.handle, 
        count,
        vals))
  self
end