Class: PLSQL::Type

Inherits:
Object
  • Object
show all
Extended by:
TypeClassMethods
Defined in:
lib/plsql/type.rb

Defined Under Namespace

Classes: TypeProcedure

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from TypeClassMethods

find

Constructor Details

#initialize(schema, type, override_schema_name = nil) ⇒ Type

:nodoc:



39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/plsql/type.rb', line 39

def initialize(schema, type, override_schema_name = nil) #:nodoc:
  @schema = schema
  @schema_name = override_schema_name || schema.schema_name
  @type_name = type.to_s.upcase
  @attributes = {}
  @type_procedures = {}

  @typecode, @type_object_id = @schema.select_first(
    "SELECT t.typecode, o.object_id FROM all_types t, all_objects o
    WHERE t.owner = :owner
    AND t.type_name = :type_name
    AND o.owner = t.owner
    AND o.object_name = t.type_name
    AND o.object_type = 'TYPE'",
    @schema_name, @type_name)

  @schema.select_all(
    "SELECT attr_name, attr_no,
          attr_type_name, length, precision, scale,
          attr_type_owner, attr_type_mod,
          (SELECT t.typecode FROM all_types t
          WHERE t.owner = attr_type_owner
          AND t.type_name = attr_type_name) typecode
    FROM all_type_attrs
    WHERE owner = :owner
    AND type_name = :type_name
    ORDER BY attr_no",
    @schema_name, @type_name
  ) do |r|
    attr_name, position,
          data_type, data_length, data_precision, data_scale,
          data_type_owner, data_type_mod, typecode = r
    @attributes[attr_name.downcase.to_sym] = {
      :position => position && position.to_i,
      :data_type => data_type_owner && (typecode == 'COLLECTION' ? 'TABLE' : 'OBJECT' ) || data_type,
      :data_length => data_type_owner ? nil : data_length && data_length.to_i,
      :data_precision => data_precision && data_precision.to_i,
      :data_scale => data_scale && data_scale.to_i,
      :type_owner => data_type_owner,
      :type_name => data_type_owner && data_type,
      :sql_type_name => data_type_owner && "#{data_type_owner}.#{data_type}"
    }
  end
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *args, &block) ⇒ Object

:nodoc:



111
112
113
114
115
116
117
 
# File 'lib/plsql/type.rb', line 111

def method_missing(method, *args, &block) #:nodoc:
  if procedure = find_procedure(method)
    procedure.exec_with_options(args, {}, &block)
  else
    raise ArgumentError, "No PL/SQL procedure '#{method.to_s.upcase}' found for type '#{@type_name}'"
  end
end

Instance Attribute Details

#attributes ⇒ Object (readonly)

:nodoc:



37
38
39
 
# File 'lib/plsql/type.rb', line 37

def attributes
  @attributes
end

#schema_name ⇒ Object (readonly)

:nodoc:



37
38
39
 
# File 'lib/plsql/type.rb', line 37

def schema_name
  @schema_name
end

#type_name ⇒ Object (readonly)

:nodoc:



37
38
39
 
# File 'lib/plsql/type.rb', line 37

def type_name
  @type_name
end

#type_object_id ⇒ Object (readonly)

:nodoc:



37
38
39
 
# File 'lib/plsql/type.rb', line 37

def type_object_id
  @type_object_id
end

#typecode ⇒ Object (readonly)

:nodoc:



37
38
39
 
# File 'lib/plsql/type.rb', line 37

def typecode
  @typecode
end

Instance Method Details

#attribute_names ⇒ Object

list of object type attribute names



90
91
92
 
# File 'lib/plsql/type.rb', line 90

def attribute_names
  @attribute_names ||= @attributes.keys.sort_by{|k| @attributes[k][:position]}
end

#collection? ⇒ Boolean

is type collection?

Returns:

  • (Boolean) 


85
86
87
 
# File 'lib/plsql/type.rb', line 85

def collection?
  @is_collection ||= @typecode == 'COLLECTION'
end

#find_procedure(new_or_procedure) ⇒ Object

:nodoc:



119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
# File 'lib/plsql/type.rb', line 119

def find_procedure(new_or_procedure) #:nodoc:
  @type_procedures[new_or_procedure] ||= begin
    procedure_name = new_or_procedure == :new ? @type_name : new_or_procedure
    # find defined procedure for type
    if @schema.select_first(
          "SELECT procedure_name FROM all_procedures
          WHERE owner = :owner
            AND object_name = :object_name
            AND procedure_name = :procedure_name",
          @schema_name, @type_name, procedure_name.to_s.upcase)
      TypeProcedure.new(@schema, self, procedure_name)
    # call default constructor
    elsif new_or_procedure == :new
      TypeProcedure.new(@schema, self, :new)
    end
  end
end

#new(*args, &block) ⇒ Object

create new PL/SQL object instance



95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/plsql/type.rb', line 95

def new(*args, &block)
  procedure = find_procedure(:new)
  # in case of collections pass array of elements as one argument for constructor
  if collection? && !(args.size == 1 && args[0].is_a?(Array))
    args = [args]
  end
  result = procedure.exec_with_options(args, {:skip_self => true}, &block)
  # TODO: collection constructor should return Array of ObhjectInstance objects
  if collection?
    result
  else
    # TODO: what to do if block is passed to constructor?
    ObjectInstance.create(self, result)
  end
end