baza 0.0.20 → 0.0.21

data/lib/baza/driver/pg/index.rb

@@ -0,0 +1,35 @@
+class Baza::Driver::Pg::Index < Baza::Index
+  attr_reader :name
+
+  def initialize(args)
+    @db = args.fetch(:db)
+    @data = args.fetch(:data)
+    @name = @data.fetch(:indexname)
+  end
+
+  def table
+    @db.tables[table_name]
+  end
+
+  def table_name
+    @data.fetch(:tablename)
+  end
+
+  def unique?
+    @data.fetch(:indexdef).include?(" UNIQUE ")
+  end
+
+  def primary?
+    name == "#{table_name}_pkey"
+  end
+
+  def rename(new_name)
+    @db.query("ALTER INDEX #{@db.sep_index}#{@db.escape_index(name)}#{@db.sep_index} RENAME TO #{@db.sep_index}#{@db.escape_index(new_name)}#{@db.sep_index}")
+    @name = new_name.to_s
+    self
+  end
+
+  def columns
+    @data.fetch(:indexdef).match(/\((.+)\)\Z/)[1].split(/\s*,\s/)
+  end
+end

data/lib/baza/driver/pg/indexes.rb

@@ -0,0 +1,5 @@
+class Baza::Driver::Pg::Indexes
+  def initialize(args)
+    @db = args.fetch(:db)
+  end
+end

data/lib/baza/driver/pg/result.rb

@@ -0,0 +1,139 @@
+class Baza::Driver::Pg::Result
+  def initialize(driver, result, args = nil)
+    @result = result
+    @unbuffered = true if args && args[:unbuffered]
+    @type_translation = driver.db.opts[:type_translation]
+
+    types
+  end
+
+  def to_enum
+    @enum ||= Enumerator.new do |yielder|
+      if @unbuffered
+        @result.stream_each_row do |values|
+          if @type_translation == :string
+            values = translate_values_to_strings(values)
+          elsif @type_translation
+            values = translate_values_with_types(values)
+          end
+
+          result_sym = Hash[*keys.zip(values).flatten]
+          yielder << result_sym
+        end
+      else
+        @result.each do |result|
+          values = result.values
+
+          if @type_translation == :string
+            values = translate_values_to_strings(values)
+          elsif @type_translation
+            values = translate_values_with_types(values)
+          end
+
+          result_sym = Hash[*keys.zip(values).flatten]
+          yielder << result_sym
+        end
+      end
+    end
+  end
+
+  def to_a_enum
+    ArrayEnumerator.new(to_enum)
+  end
+
+  def fetch
+    to_enum.next
+  rescue StopIteration
+    nil
+  end
+
+  def each(&blk)
+    to_enum.each(&blk)
+  rescue StopIteration
+    nil
+  end
+
+  def to_a
+    array = []
+    each do |result|
+      array << result
+    end
+
+    array
+  end
+
+private
+
+  def keys
+    unless @keys
+      @keys = []
+      @result.fields.each do |field|
+        @keys << field.to_sym
+      end
+    end
+
+    @keys
+  end
+
+  def types
+    unless @types
+      @types = []
+      @result.fields.length.times do |count|
+        type_num = @result.ftype(count)
+
+        case type_num
+        when 20, 23
+          @types << :int
+        when 16, 19, 25, 26, 28, 1034, 1043
+          @types << :string
+        when 701
+          @types << :float
+        when 1114
+          @types << :time
+        when 1082
+          @types << :date
+        else
+          if @debug
+            data = nil
+            @result.each do |data_i|
+              data = data_i
+              break
+            end
+
+            value = data.values[count] if data
+
+            raise "Unknown type number: #{type_num} for this field: #{@result.fields[count]}: #{value}"
+          else
+            @types << :string
+          end
+        end
+      end
+    end
+
+    @types
+  end
+
+  def translate_values_with_types(values)
+    values.collect!.with_index do |value, count|
+      type_sym = types[count]
+
+      if type_sym == :int
+        value.to_i
+      elsif type_sym == :float
+        value.to_f
+      elsif type_sym == :time
+        Time.parse(value)
+      elsif type_sym == :date
+        Date.parse(value)
+      elsif type_sym == :string
+        value
+      else
+        raise "Unknown type symbol: #{type_sym}"
+      end
+    end
+  end
+
+  def translate_values_to_strings(values)
+    values.map!(&:to_s)
+  end
+end

data/lib/baza/driver/pg/table.rb

@@ -0,0 +1,184 @@
+class Baza::Driver::Pg::Table < Baza::Table
+  attr_reader :name
+
+  def initialize(args)
+    @db = args.fetch(:driver).db
+    @data = args.fetch(:data)
+    @name = @data.fetch(:table_name)
+  end
+
+  def drop
+    @db.with_database(database_name) do
+      @db.query("DROP TABLE \"#{@db.escape_table(name)}\"")
+    end
+  end
+
+  def database_name
+    @data.fetch(:table_catalog)
+  end
+
+  def native?
+    false
+  end
+
+  def columns(args = {})
+    where_args = {
+      table_catalog: @db.opts[:db],
+      table_name: name,
+      table_schema: "public"
+    }
+
+    where_args[:column_name] = args.fetch(:name) if args[:name]
+
+    columns_list = [] unless block_given?
+    @db.select([:information_schema, :columns], where_args) do |column_data|
+      column = Baza::Driver::Pg::Column.new(
+        db: @db,
+        data: column_data
+      )
+
+      if columns_list
+        columns_list << column
+      else
+        yield column
+      end
+    end
+
+    columns_list
+  end
+
+  def column(name)
+    column = columns(name: name).first
+    raise Baza::Errors::ColumnNotFound unless column
+    column
+  end
+
+  def truncate
+    @db.query("TRUNCATE #{@db.sep_table}#{@db.escape_table(name)}#{@db.sep_table} RESTART IDENTITY")
+    self
+  end
+
+  def indexes(args = {})
+    where_args = {
+      tablename: name
+    }
+
+    where_args[:indexname] = args.fetch(:name) if args[:name]
+
+    indexes_list = [] unless block_given?
+    @db.select(:pg_indexes, where_args) do |index_data|
+      index = Baza::Driver::Pg::Index.new(
+        db: @db,
+        data: index_data
+      )
+
+      next if index.primary?
+
+      if indexes_list
+        indexes_list << index
+      else
+        yield index
+      end
+    end
+
+    indexes_list
+  end
+
+  def index(name)
+    index = indexes(name: name).first
+    raise Baza::Errors::IndexNotFound unless index
+    index
+  end
+
+  def create_indexes(index_list, args = {})
+    Baza::Driver::Pg::Table.create_indexes(index_list, args.merge(table_name: name, db: @db))
+  end
+
+  def self.create_indexes(index_list, args = {})
+    db = args.fetch(:db)
+    sqls = Baza::Driver::Pg::CreateIndexSqlCreator.new(db: db, indexes: index_list, create_args: args).sqls
+
+    unless args[:return_sql]
+      db.transaction do
+        sqls.each do |sql|
+          db.query(sql)
+        end
+      end
+    end
+
+    sqls if args[:return_sql]
+  end
+
+  def rename(new_name)
+    @db.query("ALTER TABLE #{@db.sep_table}#{@db.escape_table(name)}#{@db.sep_table} RENAME TO #{@db.sep_table}#{@db.escape_table(new_name)}#{@db.sep_table}")
+    @name = new_name.to_s
+    self
+  end
+
+  def reload
+    where_args = {
+      table_catalog: @db.opts.fetch(:db),
+      table_schema: "public",
+      table_name: name
+    }
+
+    data = @db.single([:information_schema, :tables], where_args)
+    raise Baza::Errors::TableNotFound unless data
+    @data = data
+    self
+  end
+
+  def optimize
+    @db.query("VACUUM #{@db.sep_table}#{@db.escape_table(name)}#{@db.sep_table}")
+    self
+  end
+
+  def clone(newname, _args = {})
+    raise "Invalid name." if newname.to_s.strip.empty?
+
+    columns_list = []
+    indexes_list = []
+
+    columns do |column|
+      columns_list << column.data
+    end
+
+    indexes do |index|
+      data = index.data
+      data.delete(:name)
+      indexes_list << data
+    end
+
+    @db.tables.create(newname, columns: columns_list, indexes: indexes_list)
+
+    clone_insert_from_original_table(newname, columns_list)
+
+    @db.tables[newname]
+  end
+
+private
+
+  def clone_insert_from_original_table(newname, columns_list)
+    sql_clone = "INSERT INTO #{@db.sep_table}#{@db.escape_table(newname)}#{@db.sep_table} ("
+
+    first = true
+    columns_list.each do |column_data|
+      sql_clone << "," unless first
+      first = false if first
+      sql_clone << "#{@db.sep_col}#{@db.escape_column(column_data.fetch(:name))}#{@db.sep_col}"
+    end
+
+    sql_clone << ") SELECT "
+
+    first = true
+    columns_list.each do |column_data|
+      sql_clone << "," unless first
+      first = false if first
+      sql_clone << "#{@db.sep_col}#{@db.escape_column(column_data.fetch(:name))}#{@db.sep_col}"
+    end
+
+    sql_clone << " FROM #{@db.sep_table}#{@db.escape_table(name)}#{@db.sep_table}"
+
+    @db.query(sql_clone)
+  end
+end

data/lib/baza/driver/pg/tables.rb

@@ -0,0 +1,45 @@
+class Baza::Driver::Pg::Tables
+  attr_reader :db
+
+  def initialize(args)
+    @args = args
+    @db = @args.fetch(:db)
+  end
+
+  def [](table_name)
+    table = list(name: table_name).first
+    raise Baza::Errors::TableNotFound unless table
+    table
+  end
+
+  def list(args = {})
+    tables_list = [] unless block_given?
+
+    where_args = {
+      table_catalog: @db.opts[:db],
+      table_schema: "public"
+    }
+    where_args[:table_name] = args.fetch(:name) if args[:name]
+
+    @db.select([:information_schema, :tables], where_args, orderby: :table_name) do |table_data|
+      table = Baza::Driver::Pg::Table.new(
+        driver: @db.driver,
+        data: table_data
+      )
+
+      next if table.native?
+
+      if tables_list
+        tables_list << table
+      else
+        yield table
+      end
+    end
+
+    tables_list
+  end
+
+  def create(name, data, args = nil)
+    @db.current_database.create_table(name, data, args)
+  end
+end

data/lib/baza/{drivers → driver}/sqlite3.rb

@@ -1,18 +1,6 @@
 # This class handels SQLite3-specific behaviour.
 class Baza::Driver::Sqlite3 < Baza::BaseSqlDriver
-  path = "#{File.dirname(__FILE__)}/sqlite3"
-
-  autoload :Database, "#{path}/database"
-  autoload :Databases, "#{path}/databases"
-  autoload :Table, "#{path}/table"
-  autoload :Tables, "#{path}/tables"
-  autoload :Column, "#{path}/column"
-  autoload :Columns, "#{path}/columns"
-  autoload :Index, "#{path}/index"
-  autoload :Indexes, "#{path}/indexes"
-  autoload :Result, "#{path}/result"
-  autoload :Sqlspecs, "#{path}/sqlspecs"
-  autoload :UnbufferedResult, "#{path}/unbuffered_result"
+  AutoAutoloader.autoload_sub_classes(self, __FILE__)
 
   attr_reader :mutex_statement_reader
 
@@ -37,14 +25,14 @@ class Baza::Driver::Sqlite3 < Baza::BaseSqlDriver
   end
 
   # Constructor. This should not be called manually.
-  def initialize(baza_db)
+  def initialize(db)
     super
 
-    @path = @baza.opts[:path] if @baza.opts[:path]
+    @path = @db.opts[:path] if @db.opts[:path]
     @mutex_statement_reader = Mutex.new
 
-    if @baza.opts[:conn]
-      @conn = @baza.opts[:conn]
+    if @db.opts[:conn]
+      @conn = @db.opts[:conn]
     else
       raise "No path was given." unless @path
       require "sqlite3" unless ::Object.const_defined?(:SQLite3)
@@ -72,12 +60,6 @@ class Baza::Driver::Sqlite3 < Baza::BaseSqlDriver
     string.to_s.gsub(/'/, "''")
   end
 
-  # Returns the last inserted ID.
-  def last_id
-    return @conn.last_insert_row_id if @conn.respond_to?(:last_insert_row_id)
-    query("SELECT last_insert_rowid() AS id").fetch[:id].to_i
-  end
-
   # Closes the connection to the database.
   def close
     @mutex_statement_reader.synchronize { @conn.close }
@@ -85,7 +67,7 @@ class Baza::Driver::Sqlite3 < Baza::BaseSqlDriver
 
   # Starts a transaction, yields the database and commits.
   def transaction
-    @conn.transaction { yield @baza }
+    @conn.transaction { yield @db }
   end
 
   def supports_multiple_databases?