baza 0.0.20 → 0.0.21

data/lib/baza/driver/mysql_java/users.rb

@@ -0,0 +1,2 @@
+class Baza::Driver::MysqlJava::Users < Baza::Driver::Mysql::Users
+end

data/lib/baza/driver/pg.rb

@@ -0,0 +1,80 @@
+class Baza::Driver::Pg < Baza::BaseSqlDriver
+  AutoAutoloader.autoload_sub_classes(self, __FILE__)
+
+  attr_reader :conn
+
+  def self.from_object(args)
+    if args[:object].class.name == "PG::Connection"
+      return {
+        type: :success,
+        args: {
+          type: :pg,
+          conn: args[:object]
+        }
+      }
+    end
+
+    nil
+  end
+
+  def self.args
+    [{
+      label: "Host",
+      name: "host"
+    }, {
+      label: "Port",
+      name: "port"
+    }, {
+      label: "Username",
+      name: "user"
+    }, {
+      label: "Password",
+      name: "pass"
+    }, {
+      label: "Database",
+      name: "db"
+    }]
+  end
+
+  def initialize(db)
+    super
+
+    @sep_database = '"'
+    @sep_table = '"'
+    @sep_col = '"'
+    @sep_index = '"'
+
+    if db.opts[:conn]
+      @conn = db.opts.fetch(:conn)
+    else
+      reconnect
+    end
+  end
+
+  def reconnect
+    require "pg" unless ::Object.const_defined?(:PG)
+
+    args = {dbname: db.opts.fetch(:db)}
+    args[:port] = db.opts.fetch(:port) if db.opts[:port]
+    args[:hostaddr] = db.opts.fetch(:host) if db.opts[:host]
+    args[:user] = db.opts.fetch(:user) if db.opts[:user]
+    args[:password] = db.opts.fetch(:pass) if db.opts[:pass]
+
+    @conn = PG::Connection.new(args)
+  end
+
+  def query(sql)
+    Baza::Driver::Pg::Result.new(self, @conn.exec(sql))
+  end
+
+  def query_ubuf(sql)
+    @conn.send_query(sql)
+    @conn.set_single_row_mode
+    result = @conn.get_result
+    Baza::Driver::Pg::Result.new(self, result, unbuffered: true)
+  end
+
+  def close
+    @conn.close
+  end
+end

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

@@ -0,0 +1,125 @@
+class Baza::Driver::Pg::Column < Baza::Column
+  attr_reader :name
+
+  def initialize(args)
+    @db = args.fetch(:db)
+    @data = args.fetch(:data)
+    @name = @data.fetch(:column_name)
+  end
+
+  def table_name
+    @data.fetch(:table_name)
+  end
+
+  def type
+    unless @type
+      type = @data.fetch(:udt_name)
+
+      if type == "int4"
+        @type = :int
+      else
+        @type = type.to_sym
+      end
+    end
+
+    @type
+  end
+
+  def maxlength
+    @data.fetch(:character_maximum_length)
+  end
+
+  def null?
+    @data.fetch(:is_nullable) == "YES"
+  end
+
+  def primarykey?
+    autoincr?
+  end
+
+  def autoincr?
+    !@data.fetch(:column_default).to_s.match(/\Anextval\('#{Regexp.escape(table_name)}_#{Regexp.escape(name)}_seq'::regclass\)\Z/).nil?
+  end
+
+  def default
+    return nil if autoincr?
+    @data.fetch(:column_default)
+  end
+
+  def drop
+    @db.query("ALTER TABLE #{@db.sep_table}#{@db.escape_table(table_name)}#{@db.sep_table} DROP COLUMN #{@db.sep_col}#{@db.escape_column(name)}#{@db.sep_col}")
+    nil
+  end
+
+  def reload
+    data = @db.single([:information_schema, :columns], table_name: table_name, column_name: name)
+    raise Baza::Errors::ColumnNotFound unless data
+    @data = data
+  end
+
+  def change(data)
+    if data.key?(:name) && data.fetch(:name).to_s != name
+      @db.query("#{alter_table_sql} RENAME #{col_escaped} TO #{@db.sep_col}#{@db.escape_column(data.fetch(:name))}#{@db.sep_col}")
+      @name = data.fetch(:name).to_s
+    end
+
+    change_type = true if data.key?(:type) && data.fetch(:type).to_s != type.to_s
+    change_type = true if data.key?(:maxlength) && data.fetch(:maxlength) != maxlength
+
+    if change_type
+      type = data[:type].to_s || type.to_s
+
+      if type == "int"
+        using = " USING (trim(#{name})::integer)"
+      else
+        using = ""
+      end
+
+      @db.query("#{alter_column_sql} TYPE #{data.fetch(:type)}#{using}")
+      @type = nil
+      changed = true
+    end
+
+    if data.key?(:null) && data.fetch(:null) != null?
+      if data.fetch(:null)
+        @db.query("#{alter_column_sql} DROP NOT NULL")
+      else
+        @db.query("#{alter_column_sql} ADD NOT NULL")
+      end
+
+      changed = true
+    end
+
+    if data.key?(:default) && data.fetch(:default) != default
+      if data.fetch(:default).nil?
+        @db.query("#{alter_column_sql} DROP DEFAULT")
+      else
+        default = "'#{@db.esc(data.fetch(:default))}'"
+        @db.query("#{alter_column_sql} SET DEFAULT #{default}")
+      end
+
+      changed = true
+    end
+
+    reload if changed
+    self
+  end
+
+private
+
+  def col_escaped
+    "#{@db.sep_col}#{@db.escape_column(name)}#{@db.sep_col}"
+  end
+
+  def table_escaped
+    "#{@db.sep_table}#{@db.escape_table(table_name)}#{@db.sep_table}"
+  end
+
+  def alter_table_sql
+    "ALTER TABLE #{table_escaped}"
+  end
+
+  def alter_column_sql
+    "#{alter_table_sql} ALTER COLUMN #{col_escaped}"
+  end
+end

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

@@ -0,0 +1,37 @@
+class Baza::Driver::Pg::Columns
+  def initialize(args)
+    @db = args.fetch(:db)
+  end
+
+  DATA_SQL_ALLOWED_KEYS = [:type, :maxlength, :name, :primarykey, :autoincr, :default, :comment, :after, :first, :storage, :null, :renames].freeze
+  def data_sql(data)
+    data.each_key do |key|
+      raise "Invalid key: '#{key}' (#{key.class.name})." unless DATA_SQL_ALLOWED_KEYS.include?(key)
+    end
+
+    raise "No type given." unless data[:type]
+    type = data[:type].to_sym
+    type = :serial if type == :int && data[:autoincr]
+    type = :timestamp if type == :datetime
+
+    data[:maxlength] = 255 if type == :varchar && !data.key?(:maxlength)
+
+    sql = "#{@db.sep_col}#{@db.escape_column(data.fetch(:name))}#{@db.sep_col} #{type}"
+    sql << "(#{data[:maxlength]})" if data[:maxlength]
+    sql << " PRIMARY KEY" if data[:primarykey]
+    sql << " NOT NULL" if data.key?(:null) && !data[:null]
+
+    if data.key?(:default_func)
+      sql << " DEFAULT #{data[:default_func]}"
+    elsif data.key?(:default) && data[:default]
+      sql << " DEFAULT #{@db.sqlval(data.fetch(:default))}"
+    end
+
+    sql << " COMMENT '#{@db.escape(data.fetch(:comment))}'" if data.key?(:comment)
+    sql << " AFTER #{@db.sep_col}#{@db.escape_column(data.fetch(:after))}#{@db.sep_col}" if data[:after] && !data[:first]
+    sql << " FIRST" if data[:first]
+    sql << " STORAGE #{data[:storage].to_s.upcase}" if data[:storage]
+
+    sql
+  end
+end

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

@@ -0,0 +1,35 @@
+class Baza::Driver::Pg::Commands
+  def initialize(args)
+    @db = args.fetch(:db)
+  end
+
+  def upsert_duplicate_key(table_name, updates, terms, args = {})
+    @last_insert_table_name = table_name.to_s
+
+    Baza::SqlQueries::PostgresUpsertDuplicateKey.new({
+      db: @db,
+      table_name: table_name,
+      updates: updates,
+      terms: terms
+    }.merge(args)).execute
+  end
+
+  def upsert(table_name, updates, terms, args = {})
+    @last_insert_table_name = table_name.to_s
+
+    Baza::SqlQueries::NonAtomicUpsert.new({
+      db: @db,
+      table_name: table_name,
+      terms: terms,
+      updates: updates
+    }.merge(args)).execute
+  end
+
+  def last_id
+    @db.query("SELECT LASTVAL() AS id").fetch.fetch(:id).to_i
+  end
+
+  def version
+    @version ||= @db.query("SELECT VERSION() AS version").fetch.fetch(:version).match(/\APostgreSQL ([\d\.]+)/)[1]
+  end
+end

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

@@ -0,0 +1,51 @@
+class Baza::Driver::Pg::CreateIndexSqlCreator
+  def initialize(args)
+    @db = args.fetch(:db)
+    @indexes = args.fetch(:indexes)
+    @create_args = args.fetch(:create_args)
+  end
+
+  def sqls
+    sqls = []
+    @indexes.each do |index_data|
+      sqls << create_sql(index_data, @create_args)
+    end
+
+    sqls
+  end
+
+  def name_from_table_and_columns(table_name, column_names)
+    "index_on_#{table_name}_#{column_names.join("_")}"
+  end
+
+  def create_sql(index_data, args)
+    sql = ""
+    sql << "CREATE" if args[:create] || !args.key?(:create)
+
+    if index_data.is_a?(String) || index_data.is_a?(Symbol)
+      index_data = {name: index_data, columns: [index_data]}
+    elsif index_data[:name].to_s.strip.empty?
+      index_data[:name] = name_from_table_and_columns(args[:table_name] || name, index_data.fetch(:columns))
+    end
+
+    raise "No columns was given on index: '#{index_data.fetch(:name)}'." if !index_data[:columns] || index_data[:columns].empty?
+
+    sql << " UNIQUE" if index_data[:unique]
+    sql << " INDEX #{@db.sep_index}#{@db.escape_index(index_data.fetch(:name))}#{@db.sep_index}"
+
+    if args[:on_table] || !args.key?(:on_table)
+      sql << " ON #{@db.sep_table}#{@db.escape_table(args.fetch(:table_name))}#{@db.sep_table}"
+    end
+
+    sql << " ("
+
+    first = true
+    index_data.fetch(:columns).each do |col_name|
+      sql << ", " unless first
+      first = false if first
+      sql << "#{@db.sep_col}#{@db.escape_column(col_name)}#{@db.sep_col}"
+    end
+
+    sql << ")"
+  end
+end

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

@@ -0,0 +1,89 @@
+class Baza::Driver::Pg::Database < Baza::Database
+  def save!
+    rename(name) unless name.to_s == name_was
+    self
+  end
+
+  def drop
+    @db.query("DROP DATABASE #{@db.sep_database}#{@db.escape_database(name)}#{@db.sep_database}")
+    self
+  end
+
+  def table(table_name)
+    table = tables(name: table_name).first
+    raise Baza::Errors::TableNotFound unless table
+    table
+  end
+
+  def tables(args = {})
+    tables_list = [] unless block_given?
+
+    where_args = {
+      table_catalog: name,
+      table_schema: "public"
+    }
+    where_args[:table_name] = args.fetch(:name) if args[:name]
+
+    use do
+      @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
+    end
+
+    tables_list
+  end
+
+  def use(&blk)
+    @db.with_database(name, &blk)
+    self
+  end
+
+  CREATE_ALLOWED_KEYS = [:columns, :indexes, :temp, :return_sql].freeze
+  # Creates a new table by the given name and data.
+  def create_table(table_name, data, args = nil)
+    table_name = table_name.to_s
+    raise "No columns was given for '#{name}'." if !data[:columns] || data[:columns].empty?
+
+    sql = "CREATE"
+    sql << " TEMPORARY" if data[:temp]
+    sql << " TABLE #{db.sep_table}#{@db.escape_table(table_name)}#{db.sep_table} ("
+
+    first = true
+    data.fetch(:columns).each do |col_data|
+      sql << ", " unless first
+      first = false if first
+      col_data.delete(:after) if col_data[:after]
+      sql << @db.columns.data_sql(col_data)
+    end
+
+    sql << ")"
+
+    use { @db.query(sql) } if !args || !args[:return_sql]
+
+    if data[:indexes] && !data[:indexes].empty?
+      table = @db.tables[table_name]
+      table.create_indexes(data.fetch(:indexes))
+    end
+
+    return [sql] if args && args[:return_sql]
+  end
+
+private
+
+  def rename(new_name)
+    @db.query("ALTER DATABASE #{@db.sep_database}#{@db.escape_database(name_was)}#{@db.sep_database} RENAME TO #{@db.sep_database}#{@db.escape_database(new_name)}#{@db.sep_database}")
+    @name = new_name.to_s
+    self
+  end
+end

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

@@ -0,0 +1,79 @@
+class Baza::Driver::Pg::Databases
+  def initialize(args)
+    @db = args.fetch(:db)
+  end
+
+  def current_database
+    @db.databases[current_database_name]
+  end
+
+  def current_database_name
+    @db.query("SELECT current_database()").fetch.values.first
+  end
+
+  def create(args)
+    if args[:if_not_exists]
+      begin
+        __send__(:[], args.fetch(:name).to_s)
+        return true
+      # rubocop:disable Lint/HandleExceptions
+      rescue Baza::Errors::DatabaseNotFound
+        # rubocop:enable Lint/HandleExceptions
+      end
+    end
+
+    @db.query("CREATE DATABASE #{@db.sep_database}#{@db.escape_table(args.fetch(:name))}#{@db.sep_database}")
+    true
+  end
+
+  def [](name)
+    database = list(name: name).first
+    raise Baza::Errors::DatabaseNotFound unless database
+    database
+  end
+
+  def list(args = {})
+    where_args = {}
+    where_args[:datname] = args.fetch(:name) if args[:name]
+
+    database_list = [] unless block_given?
+    @db.select(:pg_database, where_args) do |database_data|
+      database = Baza::Driver::Pg::Database.new(
+        db: @db,
+        driver: @db.driver,
+        name: database_data.fetch(:datname)
+      )
+
+      if database_list
+        database_list << database
+      else
+        yield database
+      end
+    end
+
+    database_list
+  end
+
+  def with_database(name)
+    if @db.opts[:db].to_s == name
+      yield if block_given?
+      return self
+    end
+
+    previous_db_name = @db.current_database_name
+
+    @db.opts[:db] = name
+    @db.driver.reconnect
+
+    if block_given?
+      begin
+        yield
+      ensure
+        @db.opts[:db] = previous_db_name
+        @db.driver.reconnect
+      end
+    end
+
+    self
+  end
+end