ruby-plsql 0.5.3 → 0.8.0

data/lib/plsql/schema.rb

@@ -13,13 +13,13 @@ module PLSQL
           @@schemas[connection_alias] = self.new
         end
       end
-
     end
 
     def initialize(raw_conn = nil, schema = nil, original_schema = nil) #:nodoc:
       self.connection = raw_conn
       @schema_name = schema ? schema.to_s.upcase : nil
       @original_schema = original_schema
+      @dbms_output_stream = nil
     end
 
     # Returns connection wrapper object (this is not raw OCI8 or JDBC connection!)
@@ -35,7 +35,7 @@ module PLSQL
     end
 
     # Set connection to OCI8 or JDBC connection:
-    # 
+    #
     #   plsql.connection = OCI8.new(database_user, database_password, database_name)
     #
     # or
@@ -90,7 +90,7 @@ module PLSQL
     # Current Oracle schema name
     def schema_name
       return nil unless connection
-      @schema_name ||= select_first("SELECT SYS_CONTEXT('userenv','session_user') FROM dual")[0]
+      @schema_name ||= select_first("SELECT SYS_CONTEXT('userenv','current_schema') FROM dual")[0]
     end
 
     # Default timezone to which database values will be converted - :utc or :local
@@ -131,9 +131,9 @@ module PLSQL
     end
 
     # Seet DBMS_OUTPUT buffer size (default is 20_000). Example:
-    # 
+    #
     #   plsql.dbms_output_buffer_size = 100_000
-    # 
+    #
     def dbms_output_buffer_size=(value)
       @dbms_output_buffer_size = value
     end
@@ -142,9 +142,9 @@ module PLSQL
     DBMS_OUTPUT_MAX_LINES = 2147483647
 
     # Specify IO stream where to log DBMS_OUTPUT from PL/SQL procedures. Example:
-    # 
+    #
     #   plsql.dbms_output_stream = STDOUT
-    # 
+    #
     def dbms_output_stream=(stream)
       @dbms_output_stream = stream
       if @dbms_output_stream.nil? && @connection
@@ -163,118 +163,113 @@ module PLSQL
 
     private
 
-    def reset_instance_variables
-      if @connection
-        @schema_objects = {}
-      else
-        @schema_objects = nil
+      def reset_instance_variables
+        if @connection
+          @schema_objects = {}
+        else
+          @schema_objects = nil
+        end
+        @schema_name = nil
+        @default_timezone = nil
       end
-      @schema_name = nil
-      @default_timezone = nil
-    end
 
-    def method_missing(method, *args, &block)
-      raise ArgumentError, "No database connection" unless connection
-      # search in database if not in cache at first
-      object = (@schema_objects[method] ||= find_database_object(method) || find_other_schema(method) ||
-         find_public_synonym(method) || find_standard_procedure(method))
+      def method_missing(method, *args, &block)
+        raise ArgumentError, "No database connection" unless connection
+        # search in database if not in cache at first
+        object = (@schema_objects[method] ||= find_database_object(method) || find_other_schema(method) ||
+           find_public_synonym(method) || find_standard_procedure(method))
 
-      raise ArgumentError, "No database object '#{method.to_s.upcase}' found" unless object
+        raise ArgumentError, "No database object '#{method.to_s.upcase}' found" unless object
 
-      if object.is_a?(Procedure)
-        object.exec(*args, &block)
-      elsif object.is_a?(Type) && !args.empty?
-        object.new(*args, &block)
-      else
-        object
+        if object.is_a?(Procedure)
+          object.exec(*args, &block)
+        elsif object.is_a?(Type) && !args.empty?
+          object.new(*args, &block)
+        else
+          object
+        end
       end
-    end
 
-    def find_database_object(name, override_schema_name = nil)
-      object_schema_name = override_schema_name || schema_name
-      object_name = name.to_s.upcase
-      if row = select_first(
-          "SELECT o.object_type, o.object_id, o.status,
-          (CASE WHEN o.object_type = 'PACKAGE'
-          THEN (SELECT ob.status FROM all_objects ob
-          WHERE ob.owner = o.owner AND ob.object_name = o.object_name AND ob.object_type = 'PACKAGE BODY')
-          ELSE NULL END) body_status
+      def find_database_object(name, override_schema_name = nil)
+        object_schema_name = override_schema_name || schema_name
+        object_name = name.to_s.upcase
+        if row = select_first(
+          "SELECT o.object_type, o.object_id
           FROM all_objects o
           WHERE owner = :owner AND object_name = :object_name
           AND object_type IN ('PROCEDURE','FUNCTION','PACKAGE','TABLE','VIEW','SEQUENCE','TYPE','SYNONYM')",
-          object_schema_name, object_name)
-        object_type, object_id, status, body_status = row
-        raise ArgumentError, "Database object '#{object_schema_name}.#{object_name}' is not in valid status\n#{
-          _errors(object_schema_name, object_name, object_type)}" if status == 'INVALID'
-        raise ArgumentError, "Package '#{object_schema_name}.#{object_name}' body is not in valid status\n#{
-          _errors(object_schema_name, object_name, 'PACKAGE BODY')}" if body_status == 'INVALID'
-        case object_type
-        when 'PROCEDURE', 'FUNCTION'
-          if (connection.database_version <=> [11, 1, 0, 0]) >= 0
-            row = select_first(
-              "SELECT p.object_id FROM all_procedures p
-               WHERE p.owner = :owner
-                 AND p.object_name = :object_name
-                 AND p.object_type = :object_type",
-               object_schema_name, object_name, object_type)
-            object_id = row[0]
+            object_schema_name, object_name)
+          object_type, object_id = row
+          case object_type
+          when "PROCEDURE", "FUNCTION"
+            if (connection.database_version <=> [11, 1, 0, 0]) >= 0
+              if row = select_first(
+                "SELECT p.object_id FROM all_procedures p
+                 WHERE p.owner = :owner
+                   AND p.object_name = :object_name
+                   AND p.object_type = :object_type",
+                   object_schema_name, object_name, object_type)
+                object_id = row[0]
+              else
+                raise ArgumentError, "Database object '#{object_schema_name}.#{object_name}' is not in valid status\n#{
+                  _errors(object_schema_name, object_name, object_type)}"
+              end
+            end
+            Procedure.new(self, name, nil, override_schema_name, object_id)
+          when "PACKAGE"
+            Package.new(self, name, override_schema_name)
+          when "TABLE"
+            Table.new(self, name, override_schema_name)
+          when "VIEW"
+            View.new(self, name, override_schema_name)
+          when "SEQUENCE"
+            Sequence.new(self, name, override_schema_name)
+          when "TYPE"
+            Type.new(self, name, override_schema_name)
+          when "SYNONYM"
+            target_schema_name, target_object_name = @connection.describe_synonym(object_schema_name, object_name)
+            find_database_object(target_object_name, target_schema_name)
           end
-          Procedure.new(self, name, nil, override_schema_name, object_id)
-        when 'PACKAGE'
-          Package.new(self, name, override_schema_name)
-        when 'TABLE'
-          Table.new(self, name, override_schema_name)
-        when 'VIEW'
-          View.new(self, name, override_schema_name)
-        when 'SEQUENCE'
-          Sequence.new(self, name, override_schema_name)
-        when 'TYPE'
-          Type.new(self, name, override_schema_name)
-        when 'SYNONYM'
-          target_schema_name, target_object_name = @connection.describe_synonym(object_schema_name, object_name)
-          find_database_object(target_object_name, target_schema_name)
         end
       end
-    end
 
-    def _errors(object_schema_name, object_name, object_type)
-      result = ""
-      previous_line = 0
-      select_all(
-        "SELECT e.line, e.position, e.text error_text, s.text source_text
-        FROM all_errors e, all_source s
-        WHERE e.owner = :owner AND e.name = :name AND e.type = :type
-          AND s.owner = e.owner AND s.name = e.name AND s.type = e.type AND s.line = e.line
-        ORDER BY e.sequence",
-        object_schema_name, object_name, object_type
-      ).each do |line, position, error_text, source_text|
-        result << "Error on line #{'%4d' % line}: #{source_text}" if line > previous_line
-        result << "     position #{'%4d' % position}: #{error_text}\n"
-        previous_line = line
+      def _errors(object_schema_name, object_name, object_type)
+        result = ""
+        previous_line = 0
+        select_all(
+          "SELECT e.line, e.position, e.text error_text, s.text source_text
+          FROM all_errors e, all_source s
+          WHERE e.owner = :owner AND e.name = :name AND e.type = :type
+            AND s.owner = e.owner AND s.name = e.name AND s.type = e.type AND s.line = e.line
+          ORDER BY e.sequence",
+          object_schema_name, object_name, object_type
+        ).each do |line, position, error_text, source_text|
+          result << "Error on line #{'%4d' % line}: #{source_text}" if line > previous_line
+          result << "     position #{'%4d' % position}: #{error_text}\n"
+          previous_line = line
+        end
+        result unless result.empty?
       end
-      result unless result.empty?
-    end
 
-    def find_other_schema(name)
-      return nil if @original_schema
-      if select_first("SELECT username FROM all_users WHERE username = :username", name.to_s.upcase)
-        Schema.new(connection, name, self)
-      else
-        nil
+      def find_other_schema(name)
+        return nil if @original_schema
+        if select_first("SELECT username FROM all_users WHERE username = :username", name.to_s.upcase)
+          Schema.new(connection, name, self)
+        else
+          nil
+        end
       end
-    end
-
-    def find_standard_procedure(name)
-      return nil if @original_schema
-      Procedure.find(self, name, 'STANDARD', 'SYS')
-    end
 
-    def find_public_synonym(name)
-      return nil if @original_schema
-      target_schema_name, target_object_name = @connection.describe_synonym('PUBLIC', name)
-      find_database_object(target_object_name, target_schema_name) if target_schema_name
-    end
+      def find_standard_procedure(name)
+        return nil if @original_schema
+        Procedure.find(self, name, "STANDARD", "SYS")
+      end
 
+      def find_public_synonym(name)
+        return nil if @original_schema
+        target_schema_name, target_object_name = @connection.describe_synonym("PUBLIC", name)
+        find_database_object(target_object_name, target_schema_name) if target_schema_name
+      end
   end
 end
 

data/lib/plsql/sequence.rb

@@ -1,22 +1,21 @@
 module PLSQL
-
   module SequenceClassMethods #:nodoc:
     def find(schema, sequence)
       if schema.select_first(
-            "SELECT sequence_name FROM all_sequences
-            WHERE sequence_owner = :owner
-              AND sequence_name = :sequence_name",
+        "SELECT sequence_name FROM all_sequences
+        WHERE sequence_owner = :owner
+          AND sequence_name = :sequence_name",
             schema.schema_name, sequence.to_s.upcase)
         new(schema, sequence)
       # search for synonym
       elsif (row = schema.select_first(
-            "SELECT t.sequence_owner, t.sequence_name
-            FROM all_synonyms s, all_sequences t
-            WHERE s.owner IN (:owner, 'PUBLIC')
-              AND s.synonym_name = :synonym_name
-              AND t.sequence_owner = s.table_owner
-              AND t.sequence_name = s.table_name
-            ORDER BY DECODE(s.owner, 'PUBLIC', 1, 0)",
+        "SELECT t.sequence_owner, t.sequence_name
+        FROM all_synonyms s, all_sequences t
+        WHERE s.owner IN (:owner, 'PUBLIC')
+          AND s.synonym_name = :synonym_name
+          AND t.sequence_owner = s.table_owner
+          AND t.sequence_name = s.table_name
+        ORDER BY DECODE(s.owner, 'PUBLIC', 1, 0)",
             schema.schema_name, sequence.to_s.upcase))
         new(schema, row[1], row[0])
       else
@@ -43,7 +42,5 @@ module PLSQL
     def currval
       @schema.select_one "SELECT \"#{@schema_name}\".\"#{@sequence_name}\".CURRVAL FROM dual"
     end
-
   end
-
 end

data/lib/plsql/sql_statements.rb

@@ -16,7 +16,7 @@ module PLSQL
     end
 
     # Select :first or :all values. Examples:
-    # 
+    #
     #   plsql.select :first, "SELECT * FROM employees WHERE employee_id = :1", 1
     #   plsql.select :all, "SELECT * FROM employees ORDER BY employee_id"
     def select(*args)
@@ -43,9 +43,9 @@ module PLSQL
 
     # Execute COMMIT in current database session.
     # Use beforehand
-    # 
+    #
     #   plsql.connection.autocommit = false
-    # 
+    #
     # to turn off automatic commits after each statement.
     def commit
       @connection.commit
@@ -53,9 +53,9 @@ module PLSQL
 
     # Execute ROLLBACK in current database session.
     # Use beforehand
-    # 
+    #
     #   plsql.connection.autocommit = false
-    # 
+    #
     # to turn off automatic commits after each statement.
     def rollback
       @connection.rollback
@@ -64,9 +64,9 @@ module PLSQL
     # Create SAVEPOINT with specified name. Later use +rollback_to+ method to roll changes back
     # to specified savepoint.
     # Use beforehand
-    # 
+    #
     #   plsql.connection.autocommit = false
-    # 
+    #
     # to turn off automatic commits after each statement.
     def savepoint(name)
       execute "SAVEPOINT #{name}"
@@ -74,14 +74,12 @@ module PLSQL
 
     # Roll back changes to specified savepoint (that was created using +savepoint+ method)
     # Use beforehand
-    # 
+    #
     #   plsql.connection.autocommit = false
-    # 
+    #
     # to turn off automatic commits after each statement.
     def rollback_to(name)
       execute "ROLLBACK TO #{name}"
     end
-
   end
 end
-

data/lib/plsql/table.rb

@@ -1,28 +1,27 @@
 module PLSQL
-
   module TableClassMethods #:nodoc:
     def find(schema, table)
       if schema.select_first(
-            "SELECT table_name FROM all_tables
-            WHERE owner = :owner
-              AND table_name = :table_name",
+        "SELECT table_name FROM all_tables
+        WHERE owner = :owner
+          AND table_name = :table_name",
             schema.schema_name, table.to_s.upcase)
         new(schema, table)
       # search for synonym
       elsif (row = schema.select_first(
-            "SELECT t.owner, t.table_name
-            FROM all_synonyms s, all_tables t
-            WHERE s.owner = :owner
-              AND s.synonym_name = :synonym_name
-              AND t.owner = s.table_owner
-              AND t.table_name = s.table_name
-            UNION ALL
-            SELECT t.owner, t.table_name
-            FROM all_synonyms s, all_tables t
-            WHERE s.owner = 'PUBLIC'
-              AND s.synonym_name = :synonym_name
-              AND t.owner = s.table_owner
-              AND t.table_name = s.table_name",
+        "SELECT t.owner, t.table_name
+        FROM all_synonyms s, all_tables t
+        WHERE s.owner = :owner
+          AND s.synonym_name = :synonym_name
+          AND t.owner = s.table_owner
+          AND t.table_name = s.table_name
+        UNION ALL
+        SELECT t.owner, t.table_name
+        FROM all_synonyms s, all_tables t
+        WHERE s.owner = 'PUBLIC'
+          AND s.synonym_name = :synonym_name
+          AND t.owner = s.table_owner
+          AND t.table_name = s.table_name",
             schema.schema_name, table.to_s.upcase, table.to_s.upcase))
         new(schema, row[1], row[0])
       else
@@ -58,34 +57,34 @@ module PLSQL
       ) do |r|
         column_name, position,
               data_type, data_length, data_precision, data_scale, char_used,
-              data_type_owner, data_type_mod, typecode, nullable, data_default = r
+              data_type_owner, _, typecode, nullable, data_default = r
         # remove scale (n) from data_type (returned for TIMESTAMPs and INTERVALs)
-        data_type.sub!(/\(\d+\)/,'')
+        data_type.sub!(/\(\d+\)/, "")
         # store column metadata
         @columns[column_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,
-          :char_used => char_used,
-          :type_owner => data_type_owner,
-          :type_name => data_type_owner && data_type,
-          :sql_type_name => data_type_owner && "#{data_type_owner}.#{data_type}",
-          :nullable => nullable == 'Y', # store as true or false
-          :data_default => data_default && data_default.strip # remove leading and trailing whitespace
+          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,
+          char_used: char_used,
+          type_owner: data_type_owner,
+          type_name: data_type_owner && data_type,
+          sql_type_name: data_type_owner && "#{data_type_owner}.#{data_type}",
+          nullable: nullable == "Y", # store as true or false
+          data_default: data_default && data_default.strip # remove leading and trailing whitespace
         }
       end
     end
 
     # list of table column names
     def column_names
-      @column_names ||= @columns.keys.sort_by{|k| columns[k][:position]}
+      @column_names ||= @columns.keys.sort_by { |k| columns[k][:position] }
     end
 
     # General select method with :first, :all or :count as first parameter.
     # It is recommended to use #first, #all or #count method instead of this one.
-    def select(first_or_all, sql_params='', *bindvars)
+    def select(first_or_all, sql_params = "", *bindvars)
       case first_or_all
       when :first, :all
         select_sql = "SELECT * "
@@ -102,7 +101,7 @@ module PLSQL
         raise ArgumentError, "Cannot specify bind variables when passing WHERE conditions as Hash" unless bindvars.empty?
         where_sqls = []
         order_by_sql = nil
-        sql_params.each do |k,v|
+        sql_params.each do |k, v|
           if k == :order_by
             order_by_sql = " ORDER BY #{v} "
           elsif v.nil? || v == :is_null
@@ -114,7 +113,7 @@ module PLSQL
             bindvars << v
           end
         end
-        select_sql << "WHERE " << where_sqls.join(' AND ') unless where_sqls.empty?
+        select_sql << "WHERE " << where_sqls.join(" AND ") unless where_sqls.empty?
         select_sql << order_by_sql if order_by_sql
       else
         raise ArgumentError, "Only String or Hash can be provided as SQL condition argument"
@@ -131,48 +130,49 @@ module PLSQL
     #   plsql.employees.all
     #   plsql.employees.all(:order_by => :employee_id)
     #   plsql.employees.all("WHERE employee_id > :employee_id", 5)
-    # 
-    def all(sql='', *bindvars)
+    #
+    def all(sql = "", *bindvars)
       select(:all, sql, *bindvars)
     end
 
     # Select first table record using optional conditions. Examples:
-    # 
+    #
     #   plsql.employees.first
     #   plsql.employees.first(:employee_id => 1)
     #   plsql.employees.first("WHERE employee_id = 1")
     #   plsql.employees.first("WHERE employee_id = :employee_id", 1)
-    # 
-    def first(sql='', *bindvars)
+    #
+    def first(sql = "", *bindvars)
       select(:first, sql, *bindvars)
     end
 
     # Count table records using optional conditions. Examples:
-    # 
+    #
     #   plsql.employees.count
     #   plsql.employees.count("WHERE employee_id > :employee_id", 5)
-    # 
-    def count(sql='', *bindvars)
+    #
+    def count(sql = "", *bindvars)
       select(:count, sql, *bindvars)
     end
 
     # Insert record or records in table. Examples:
-    # 
+    #
     #   employee = { :employee_id => 1, :first_name => 'First', :last_name => 'Last', :hire_date => Time.local(2000,01,31) }
     #   plsql.employees.insert employee
     #   # => INSERT INTO employees VALUES (1, 'First', 'Last', ...)
-    # 
+    #
     #   employees = [employee1, employee2, ... ]  # array of many Hashes
     #   plsql.employees.insert employees
     #
     def insert(record)
       # if Array of records is passed then insert each individually
       if record.is_a?(Array)
-        record.each {|r| insert(r)}
+        record.each { |r| insert(r) }
         return nil
       end
 
       table_proc = TableProcedure.new(@schema, self, :insert)
+      record = record.map { |k, v| [k.downcase.to_sym, v] }.to_h
       table_proc.add_insert_arguments(record)
 
       call = ProcedureCall.new(table_proc, table_proc.argument_values)
@@ -180,15 +180,15 @@ module PLSQL
     end
 
     # Insert record or records in table using array of values. Examples:
-    # 
+    #
     #   # with values for all columns
     #   plsql.employees.insert_values [1, 'First', 'Last', Time.local(2000,01,31)]
     #   # => INSERT INTO employees VALUES (1, 'First', 'Last', ...)
-    # 
+    #
     #   # with values for specified columns
     #   plsql.employees.insert_values [:employee_id, :first_name, :last_name], [1, 'First', 'Last']
     #   # => INSERT INTO employees (employee_id, first_name, last_name) VALUES (1, 'First', 'Last')
-    # 
+    #
     #   # with values for many records
     #   plsql.employees.insert_values [:employee_id, :first_name, :last_name], [1, 'First', 'Last'], [2, 'Second', 'Last']
     #   # => INSERT INTO employees (employee_id, first_name, last_name) VALUES (1, 'First', 'Last')
@@ -197,7 +197,7 @@ module PLSQL
     def insert_values(*args)
       raise ArgumentError, "no arguments given" unless args.first
       # if first argument is array of symbols then use it as list of fields
-      if args.first.all?{|a| a.instance_of?(Symbol)}
+      if args.first.all? { |a| a.instance_of?(Symbol) }
         fields = args.shift
       # otherwise use all columns as list of fields
       else
@@ -211,14 +211,14 @@ module PLSQL
     end
 
     # Update table records using optional conditions. Example:
-    # 
+    #
     #   plsql.employees.update(:first_name => 'Second', :where => {:employee_id => 1})
     #   # => UPDATE employees SET first_name = 'Second' WHERE employee_id = 1
     #
     def update(params)
       raise ArgumentError, "Only Hash parameter can be passed to table update method" unless params.is_a?(Hash)
       where = params.delete(:where)
-      
+
       table_proc = TableProcedure.new(@schema, self, :update)
       table_proc.add_set_arguments(params)
       table_proc.add_where_arguments(where) if where
@@ -227,11 +227,11 @@ module PLSQL
     end
 
     # Delete table records using optional conditions. Example:
-    # 
+    #
     #   plsql.employees.delete(:employee_id => 1)
     #   # => DELETE FROM employees WHERE employee_id = 1
-    # 
-    def delete(sql_params='', *bindvars)
+    #
+    def delete(sql_params = "", *bindvars)
       delete_sql = "DELETE FROM \"#{@schema_name}\".\"#{@table_name}\" "
       case sql_params
       when String
@@ -239,11 +239,11 @@ module PLSQL
       when Hash
         raise ArgumentError, "Cannot specify bind variables when passing WHERE conditions as Hash" unless bindvars.empty?
         where_sqls = []
-        sql_params.each do |k,v|
+        sql_params.each do |k, v|
           where_sqls << "#{k} = :#{k}"
           bindvars << v
         end
-        delete_sql << "WHERE " << where_sqls.join(' AND ') unless where_sqls.empty?
+        delete_sql << "WHERE " << where_sqls.join(" AND ") unless where_sqls.empty?
       else
         raise ArgumentError, "Only String or Hash can be provided as SQL condition argument"
       end
@@ -287,7 +287,7 @@ module PLSQL
       end
 
       def add_insert_arguments(params)
-        params.each do |k,v|
+        params.each do |k, v|
           raise ArgumentError, "Invalid column name #{k.inspect} specified as argument" unless (column_metadata = @table.columns[k])
           @argument_list[0] << k
           @arguments[0][k] = column_metadata
@@ -296,7 +296,7 @@ module PLSQL
       end
 
       def add_set_arguments(params)
-        params.each do |k,v|
+        params.each do |k, v|
           raise ArgumentError, "Invalid column name #{k.inspect} specified as argument" unless (column_metadata = @table.columns[k])
           @argument_list[0] << k
           @arguments[0][k] = column_metadata
@@ -308,7 +308,7 @@ module PLSQL
       def add_where_arguments(params)
         case params
         when Hash
-          params.each do |k,v|
+          params.each do |k, v|
             raise ArgumentError, "Invalid column name #{k.inspect} specified as argument" unless (column_metadata = @table.columns[k])
             @argument_list[0] << :"w_#{k}"
             @arguments[0][:"w_#{k}"] = column_metadata
@@ -332,7 +332,7 @@ module PLSQL
       def call_sql(params_string)
         case @operation
         when :insert
-          "INSERT INTO \"#{@table.schema_name}\".\"#{@table.table_name}\"(#{@argument_list[0].map{|a| a.to_s}.join(', ')}) VALUES (#{params_string});\n"
+          "INSERT INTO \"#{@table.schema_name}\".\"#{@table.table_name}\"(#{@argument_list[0].map { |a| a.to_s }.join(', ')}) VALUES (#{params_string});\n"
         when :update
           update_sql = "UPDATE \"#{@table.schema_name}\".\"#{@table.table_name}\" SET #{@set_sqls.join(', ')}"
           update_sql << " WHERE #{@where_sqls.join(' AND ')}" unless @where_sqls.empty?
@@ -340,9 +340,6 @@ module PLSQL
           update_sql
         end
       end
-
     end
-
   end
-
 end