intersys 0.1 → 0.2

data/lib/intersys_adapter.rb

@@ -0,0 +1,132 @@
+# Author/Maintainer: Max Lapshin <max@maxidoors.ru>
+
+require 'rubygems'
+require_gem 'activerecord'
+
+require 'active_record/connection_adapters/abstract_adapter'
+
+module ActiveRecord
+  class Base
+    def self.intersys_connection(config)
+      config = config.symbolize_keys
+      require 'intersys'
+      intersys = Intersys::Database.new(config)
+      ConnectionAdapters::IntersysAdapter.new(intersys, logger, config)
+    end
+  end
+  
+  module ConnectionAdapters
+    class IntersysAdapter < AbstractAdapter
+      attr_reader :config
+      def initialize(database, logger, config)
+        super(database, logger)
+        @config = config
+      end
+      
+      def adapter_name #:nodoc:
+        'Intersys Caché'
+      end
+      
+      def supports_migrations? #:nodoc:
+        false
+      end
+      
+      def active?
+        warn "IntersysAdapter#active? not implemented"
+        return true
+        @connection.query "select 1"
+      rescue Intersys::IntersysException
+        false
+      end
+      
+      def disconnect!
+        @connection.close! rescue nil
+      end
+      
+      def reconnect!
+        disconnect!
+        connect
+      end
+      
+      def begin_db_transaction
+        @connection.start
+      end
+      def commit_db_transaction
+        @connection.commit
+      end
+      def rollback_db_transaction
+        @connection.rollback
+      end
+      
+      def add_limit_offset!(sql, options)
+        sql << " LIMIT #{limit}" if limit = options[:limit]
+        sql << " OFFSET #{offset}" if offset = options[:offset]
+      end
+      
+      def select_all(sql, name = nil) #:nodoc:
+        select(sql, name)
+      end
+
+      def select_one(sql, name = nil) #:nodoc:
+        result = select(sql, name)
+        result.nil? ? nil : result.first
+      end
+
+      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
+        execute(sql, name = nil)
+        id_value || @connection.insert_id
+      end
+
+      def update(sql, name = nil) #:nodoc:
+        execute(sql, name)
+        @connection.affected_rows
+      end
+
+      alias_method :delete, :update #:nodoc:
+        
+      
+      
+      def columns(table_name, name = nil)
+        @cdef = Intersys::Reflection::ClassDefinition.open("User.#{table_name.camelize}")
+        result = [IntersysColumn.new("id", "", "int")]
+        @cdef.properties.each do |prop|
+          result << IntersysColumn.new(prop.sql_field_name, prop.initial_expression, prop.Type.gsub("%","").underscore, prop.required)
+        end
+        result
+      end
+
+      def native_database_types
+        {
+          :primary_key => 'int generated by default as identity (start with 42) primary key',
+          :string      => { :name => 'varchar', :limit => 255 },
+          :text        => { :name => 'clob', :limit => 32768 },
+          :integer     => { :name => 'int' },
+          :float       => { :name => 'float' },
+          :datetime    => { :name => 'timestamp' },
+          :timestamp   => { :name => 'timestamp' },
+          :time        => { :name => 'time' },
+          :date        => { :name => 'date' },
+          :binary      => { :name => 'blob', :limit => 32768 },
+          :boolean     => { :name => 'decimal', :limit => 1 }
+        }
+      end
+      
+    protected
+      # :nodoc
+      def connect
+        @connection = Intersys::Database.new(config)
+      end
+      
+      def select(sql, name = nil)
+        @connection.query(sql)
+      end
+
+      def execute(sql, name = nil)
+        @connection.execute(sql)
+      end
+    end
+    
+    class IntersysColumn < Column
+    end
+  end
+end

data/lib/object.rb

@@ -0,0 +1,163 @@
+module Intersys
+# Basic class for all classes, through which is performed access to Cache classes
+# For each Cache class must be created ruby class, inherited from Intersys::Object
+# 
+# By default prefix "User" is selected. If Cache class has another prefix, it must
+# be provided explicitly via method "prefix":
+#   class List < Intersys::Object
+#     prefix "%Library"
+#   end
+#
+# By default name of Cache class is taken the same as name of ruby class.
+# Thus in this example this class List will be marshalled to Cache class 
+# %Library.List
+#
+class Object
+
+  class << self
+  protected      
+    def class_names
+      common_get_or_set("@class_names", {})
+    end
+
+    def prefix=(name)
+      @prefix = name
+      @class_name = @prefix + "." + (@class_name ? @class_name.split(".").last : self.to_s)
+      register_name!
+    end
+
+    def class_name=(name)
+      if name.index(".")
+        self.prefix = name.split(".").first
+        @class_name = name
+      else
+        @class_name = self.prefix + "." + name
+      end
+      register_name!
+    end
+
+    # Register class name of current class in global list
+    def register_name!
+      if i = class_names.index(self)
+        class_names.delete(i)
+      end
+      class_names[class_name] = self
+      class_name
+    end
+    
+  public
+    # Nice function, that generates description of Cache class, looking just as C++ one
+    # Maybe, later, it will be possible even to generate IDL, using this code
+    def intersys_description
+      "class #{class_name} { \n" + intersys_reflector.all_methods.map do |mtd| 
+        begin
+          "\t"+intersys_method(mtd).description+";\n"
+        rescue
+          "\tundefined #{mtd}\n"
+        end
+      end.join("") + "};"
+    end
+
+    # Help to work with instance variables of Intersys::Object class
+    # required, because list of registered descendants of Intersys::Object,
+    # database connection etc. should be in one place
+    def common_get_or_set(name, default_value = nil)
+      unless var = Intersys::Object.instance_variable_get(name)
+        default = block_given? ? yield : default_value
+        var = Intersys::Object.instance_variable_set(name, default)
+      end
+      var
+    end
+
+    # Takes Cache class name and try to resolve it to Ruby class
+    def lookup(class_name)
+      class_names[class_name] || raise(UnMarshallError, "Couldn't find registered class with Cache name '#{class_name}'")
+    end
+  
+    # Each Cache class has prefix before it's name: namespace.
+    # this method set's prefix for current class is provided,
+    # or just returns current prefix
+    def prefix(name = nil)
+      self.prefix = name if name
+      @prefix ||= "User"
+    end
+
+    # Returns Cache class name, if called without parameters, or sets one, if passed
+    def class_name(name = nil)
+      self.class_name = name if name
+      self.class_name = (prefix + "." + to_s) unless @class_name
+      @class_name 
+    end
+
+    # Returns database, if called without parameters, or sets one, if passed
+    # Once established, it is not possible now to connect to another database
+    def database(db_options = {})
+      common_get_or_set("@database") do
+        Intersys::Database.new({:user => "_SYSTEM", :password => "SYS", :namespace => "User"}.merge(db_options))
+      end
+    end
+    
+    # This method takes block and executes it between
+    # START TRANSACTION and COMMIT TRANSACTION
+    #
+    # In case of exception ROLLBACK TRANSACTION is called
+    def transaction
+      return unless block_given?
+      database.start
+      begin
+        yield
+        database.commit
+      rescue StandardError => e
+        database.rollback
+        raise e
+      end
+    end
+
+    # :nodoc
+    def inherited(klass)
+      class_names[klass.class_name] = klass
+    end
+  
+    # Look into Cache documentation for what is concurrency. I don't know
+    def concurrency
+      1
+    end
+  
+    # timeout for connection
+    def timeout
+      5
+    end
+  
+    # Nice method, that deletes all instances of class. 
+    # You can just Person.delete_extent, but Person.delete_all looks more like ActiveRecord
+    def delete_all
+      intersys_call("%DeleteExtent")
+    end
+  
+  end
+  
+  # You can ask for database from instance
+  def database
+    self.class.database
+  end
+  
+  # You can ask from instance it's Cache class name
+  def class_name
+    self.class.class_name
+  end
+  
+  # Returns id of current object.
+  # You can remove this method and You will get string ID, so leave it here
+  # However, if You ask reflector for id, it will give incorrect answer,
+  # because Cache allows id to be string
+  def id
+    intersys_call("%Id").to_i
+  end
+  
+  # Destroys current object
+  def destroy
+    self.class.intersys_call("%DeleteId", id)
+  end
+  
+end
+end

data/lib/query.c

@@ -1,4 +1,6 @@
 #include "intersys.h"
+#ifdef HAVE_SQL_H
+
 #ifdef __CYGWIN__
 #include <windef.h>
 #endif
@@ -31,8 +33,97 @@ VALUE intersys_query_initialize(VALUE self, VALUE database, VALUE sql_query) {
 	int sql_code;
 	Data_Get_Struct(self, struct rbQuery, query);
 	Data_Get_Struct(database, struct rbDatabase, base);
+	rb_iv_set(self, "@database", database);
+	query->limit = -1;
 	RUN(cbind_alloc_query(base->database, &query->query));
-	RUN(cbind_prepare_gen_query(query->query, WCHARSTR(sql_query), &sql_code));
+	RUN(cbind_prepare_gen_query(query->query, WCHARSTR(TOWCHAR(sql_query)), &sql_code));
+	return self;
+}
+
+static void query_bind_one_param(h_query query, int index, VALUE obj) {
+	int sql_type;
+    RUN(cbind_query_get_par_sql_type(query, index, &sql_type));
+
+    switch (sql_type) {
+        case SQL_CHAR:
+        case SQL_VARCHAR:
+        case SQL_LONGVARCHAR: {
+			VALUE str = rb_funcall(obj, rb_intern("to_s"), 0);
+            RUN(cbind_query_set_mb_str_par(query, index, STR(str), LEN(str)));
+            break;
+        }
+        case SQL_BINARY:
+        case SQL_LONGVARBINARY:
+        case SQL_VARBINARY: {
+			VALUE str = rb_funcall(obj, rb_intern("to_s"), 0);
+            RUN(cbind_query_set_bin_par(query, index, STR(str), LEN(str)));
+            break;
+        }
+        case SQL_TINYINT:
+        case SQL_SMALLINT:
+        case SQL_INTEGER:
+        case SQL_BIGINT:
+        case SQL_BIT:
+        {
+			VALUE num = rb_funcall(obj, rb_intern("to_i"), 0);
+            RUN(cbind_query_set_int_par(query, index, NUM2INT(num)));
+            break;
+        }
+        case SQL_FLOAT:
+        case SQL_DOUBLE:
+        case SQL_REAL:
+        case SQL_NUMERIC:
+        case SQL_DECIMAL:
+        {
+			VALUE f = rb_funcall(obj, rb_intern("to_f"), 0);
+            RUN(cbind_query_set_double_par(query, index, RFLOAT(f)->value));
+            break;
+        }
+        case SQL_TIME:
+        {
+			int hour = NUM2INT(CALL(obj, "hour"));
+			int minute = NUM2INT(CALL(obj, "min"));
+			int second = NUM2INT(CALL(obj, "sec"));
+			RUN(cbind_query_set_time_par(query, index, hour, minute, second));
+            break;
+        }
+        case SQL_DATE:
+        {
+			int year = NUM2INT(CALL(obj, "year"));
+			int month = NUM2INT(CALL(obj, "month"));
+			int day = NUM2INT(CALL(obj, "day"));
+			RUN(cbind_query_set_date_par(query, index, year, month, day));
+            break;
+        }
+        case SQL_TIMESTAMP:
+        {
+			int year = NUM2INT(CALL(obj, "year"));
+			int month = NUM2INT(CALL(obj, "month"));
+			int day = NUM2INT(CALL(obj, "day"));
+			int hour = NUM2INT(CALL(obj, "hour"));
+			int minute = NUM2INT(CALL(obj, "min"));
+			int second = NUM2INT(CALL(obj, "sec"));
+			int fraction = 0;
+		  	RUN(cbind_query_set_timestamp_par(query, index, 
+					year, month, day, hour, minute, second, fraction));
+            break;
+        }
+
+        default:
+            rb_raise(cMarshallError, "unknown sql type %d for parameter N %d", sql_type, index);
+    }
+}
+
+
+VALUE intersys_query_bind_params(VALUE self, VALUE params) {
+	int i;
+	struct rbQuery* query;
+	Check_Type(params, T_ARRAY);
+	Data_Get_Struct(self, struct rbQuery, query);
+
+	for(i = 0; i < RARRAY(params)->len; i++) {
+		query_bind_one_param(query->query, i, RARRAY(params)->ptr[i]);
+	}
 	return self;
 }
 
@@ -47,6 +138,7 @@ VALUE intersys_query_execute(VALUE self) {
 	return self;
 }
 
+
 VALUE intersys_query_get_data(VALUE self, VALUE index) {
 	struct rbQuery* query;
 	int type = 0;
@@ -129,7 +221,7 @@ VALUE intersys_query_column_name(VALUE self, VALUE i) {
 
 VALUE intersys_query_fetch(VALUE self) {
 	struct rbQuery* query;
-	VALUE data;
+	VALUE data = Qnil;
 	Data_Get_Struct(self, struct rbQuery, query);
 	int num_cols = 0;
 	int i = 0;
@@ -153,13 +245,61 @@ VALUE intersys_query_fetch(VALUE self) {
 	for(i = 0; i < num_cols; i++) {
 		rb_ary_push(data, rb_funcall(self, rb_intern("get_data"), 1, INT2FIX(i+1)));
 	}
-	rb_funcall(self, rb_intern("close"), 0);
 	return data;
 }
 
+
+VALUE intersys_query_each(VALUE self) {
+	struct rbQuery* query;
+	int i;
+	Data_Get_Struct(self, struct rbQuery, query);
+	if(query->offset > 0) {
+		RUN(cbind_query_skip(query->query, query->offset));
+	}
+	for(i = query->offset; i < query->offset + query->limit; i++) {
+		VALUE row = intersys_query_fetch(self);
+		if(row == Qnil || RARRAY(row)->len == 0) {
+			break;
+		}
+		rb_yield(row);
+	}
+	query_close(query);
+	return self;
+}
+
+
+
 VALUE intersys_query_close(VALUE self) {
 	struct rbQuery* query;
 	Data_Get_Struct(self, struct rbQuery, query);
 	query_close(query);
 	return self;
 }
+
+
+VALUE intersys_query_set_limit(VALUE self, VALUE limit) {
+	struct rbQuery* query;
+	Data_Get_Struct(self, struct rbQuery, query);
+	query->limit = NUM2INT(rb_funcall(limit, rb_intern("to_i"), 0));
+	return limit;
+}
+VALUE intersys_query_get_limit(VALUE self) {
+	struct rbQuery* query;
+	Data_Get_Struct(self, struct rbQuery, query);
+	return INT2FIX(query->limit);
+}
+
+VALUE intersys_query_set_offset(VALUE self, VALUE offset) {
+	struct rbQuery* query;
+	Data_Get_Struct(self, struct rbQuery, query);
+	query->offset = NUM2INT(rb_funcall(offset, rb_intern("to_i"), 0));
+	return offset;
+}
+
+VALUE intersys_query_get_offset(VALUE self) {
+	struct rbQuery* query;
+	Data_Get_Struct(self, struct rbQuery, query);
+	return INT2FIX(query->offset);
+}
+
+#endif /* HAVE_SQL_H */