tenant_partition 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f686ab0abe926917ef8f7b12e142570e6ace6943c725a6ebd93471fcbea4bfe
-  data.tar.gz: c88ed9c6d0e322314f4d80e8dec69312dd95e3d362e939d0467b9204f660c34f
+  metadata.gz: 4f9ccf1323d98dd3c78356387de4666127584d7539098e6501d326da1d107fa0
+  data.tar.gz: 05e849e009ee93921e6de9b8f207a6ae91781e2b177295d2ae23def5df5e07b1
 SHA512:
-  metadata.gz: 5eae8613d5ed6d0d0a8fc13d44fce4b277060b0979e8486e116614c44e508afee05ff66a5302b3eade5d45cbb4d28eb32e9114c70b88dc510e48a9a05b7ea8a7
-  data.tar.gz: 4565df6b3b073849a24a3262d43a2cabc82ad268ee0a71ccfedab1ff952dcf9a86aeacb42cf6f4331fdf59b95a3647ccf81c4f6f42e90be03aa7d59fa4af9cf9
+  metadata.gz: 368ec2f0cfc8b312ca5b5ac61eb7ace18da414faae68846e6353e7058cb5079f04777a0c6418fdd03ddd66da90df188f05d23c43dce8292a556a13d30ca48da1
+  data.tar.gz: ecab7244f3a6e106c96a27954b2df753fd1ac0143d67423b35b653c7816dfc973b946b538f1b6a6afb6dae7b0d44ff358b607bb6d394b86e17e0b9704ef86034

data/CHANGELOG.md

@@ -1,9 +1,20 @@
 ## [Unreleased]
 
-## [0.1.3] - 2026-02-03
-### Changed
-- Generator: Se simplificó el controlador API generado (se eliminó la acción `show` y el manejo de errores por defecto).
-- Fix: Se restringieron las versiones de `activemodel` y `activerecord` a `< 9.0` para evitar advertencias de RubyGems.
+## [0.2.0] - 2026-02-13
+### Changed (Breaking Changes)
+- **Arquitectura:** Se eliminó la clase `TenantPartition::Base` y la necesidad de crear modelos de infraestructura en el namespace `Partition::`.
+- **Integración:** Ahora se utiliza un concern `TenantPartition::Concerns::Partitioned` y la macro `partition_table` directamente en los modelos de dominio.
+
+### Added
+- Macro `partition_table` para activar particionamiento de forma declarativa (Opt-In).
+- Soporte para claves primarias compuestas (Composite Primary Keys) nativas de Rails 7.1+.
+- Nuevo sistema de "Registry" interno para el descubrimiento de modelos particionados (reemplaza a `ObjectSpace`).
+- Métodos de clase `create_partition`, `drop_partition` y `partition_table_exists?` inyectados directamente en el modelo.
+- Documentación actualizada con estrategias de inclusión (Global vs Local).
+
+### Fixed
+- Corrección de ofensas de RuboCop en métodos largos de generación SQL.
+- Mejoras en la seguridad de tipos en la orquestación de tareas de mantenimiento.
 
 ## [0.1.2] - 2026-02-03
 ### Added

data/README.md

@@ -1,25 +1,19 @@
 # TenantPartition
 
-**TenantPartition** es un framework de infraestructura para Ruby on Rails (7.1+) diseñado para simplificar y automatizar la gestión de **Particionamiento por Lista (List Partitioning)** nativo de PostgreSQL.
+**TenantPartition** es una solución robusta y "Rails-native" para implementar **Particionamiento Declarativo (List Partitioning)** de PostgreSQL en aplicaciones Ruby on Rails.
 
-Específicamente construido para arquitecturas **Multi-tenant**, este framework resuelve la complejidad de:
-1.  **Composite Primary Keys (CPK):** Configuración automática de claves compuestas (`id` + `partition_key`) requeridas por ActiveRecord para soportar particionamiento.
-2.  **Orquestación Centralizada:** Una única interfaz para crear y eliminar particiones en **todos** los modelos de la aplicación simultáneamente.
-3.  **Mantenimiento Zero-Downtime:** Migración atómica de datos "huérfanos" (que cayeron en la tabla `DEFAULT`) hacia sus particiones correctas sin perder servicio.
+A diferencia de otras soluciones que dependen de esquemas (schemas) o hackeos a la conexión de base de datos, `tenant_partition` utiliza características nativas de PostgreSQL para dividir tablas gigantes en tablas físicas más pequeñas por tenant (Cliente, ISP, Organización, etc.), manteniendo la experiencia de desarrollo de ActiveRecord estándar.
 
 ## 🚀 Características Principales
 
-* **Fachada de Servicio:** API unificada (`TenantPartition.create!`, `destroy!`, `audit`, `cleanup!`) para gestionar el ciclo de vida completo de los tenants.
-* **Introspección Inteligente:** Los modelos de negocio detectan automáticamente su configuración de infraestructura por convención (ej: `User` -> `Partition::User`).
-* **Migration DSL:** Helper `create_partitioned_table` para definir tablas particionadas y sus tablas `DEFAULT` en una sola instrucción.
-* **Seguridad Estricta:** Concern para controladores que valida Headers HTTP (`X-Tenant-ID`) para asegurar el contexto del tenant.
-* **Observabilidad:** Instrumentación integrada con `ActiveSupport::Notifications`.
+* **API Simple (Opt-in):** Usa `partition_table` en tus modelos para activar la magia.
+* **Soporte Nativo CPK:** Compatible con **Composite Primary Keys** de Rails 7.1+.
+* **Sin Magic Strings:** Usa métodos explícitos (`create_partition`, `drop_partition`).
+* **Gestión de Datos Huérfanos:** Herramientas para mover datos de la tabla "Default" a su partición correcta automáticamente.
+* **Safety Guards:** Protección contra borrados accidentales en Producción.
+* **Tasks de Mantenimiento:** Rake tasks integradas para auditoría y limpieza.
 
-## 📋 Requisitos
-
-* **Ruby:** >= 3.2
-* **Ruby on Rails:** >= 7.1
-* **PostgreSQL:** >= 13.0 (Requerido para `gen_random_uuid()` nativo)
+---
 
 ## 📦 Instalación
 
@@ -29,183 +23,177 @@ Agrega esto a tu `Gemfile`:
 gem 'tenant_partition'
 ```
 
-Luego ejecuta:
+Y ejecuta:
 
 ```bash
 bundle install
 ```
 
-## ⚙️ Configuración
+---
+
+## ⚙️ Configuración Inicial
 
-Crea un inicializador en `config/initializers/tenant_partition.rb`. Es **obligatorio** definir la clave de partición.
+Crea un inicializador para definir tu clave de partición global (por ejemplo, `:isp_id`, `:account_id`, `:tenant_id`).
 
 ```ruby
+# config/initializers/tenant_partition.rb
+
 TenantPartition.configure do |config|
-  # 1. La columna que discrimina los tenants (ej: :isp_id, :account_id, :tenant_id)
+  # Esta es la columna que actuará como discriminador global
   config.partition_key = :isp_id
-
-  # 2. El Header HTTP para la seguridad en controladores API
-  config.header_name   = 'X-Tenant-ID'
 end
 ```
 
-## 🛠 Guía de Uso
+---
 
-### 1. Migraciones (Crear las Tablas)
+## 🏗 Estrategias de Uso
 
-Usa el helper `create_partitioned_table`. Este método deshabilita el ID automático simple y configura una **Primary Key Compuesta** (`[:id, :partition_key]`) necesaria para que PostgreSQL permita el particionamiento.
+La gema utiliza un patrón "Opt-In". Incluir el módulo no altera tus modelos hasta que lo activas explícitamente. Puedes elegir la estrategia que mejor se adapte a tu proyecto:
+
+### Opción A: Global (Recomendado)
+Incluye el concern en `ApplicationRecord`. Esto **NO** particiona tus tablas, solo habilita la posibilidad de usar la macro `partition_table` en el futuro. Es ideal para mantener el código limpio.
 
 ```ruby
-class CreateConversations < ActiveRecord::Migration[7.1]
-  def change
-    create_partitioned_table :conversations do |t|
-      # No definas t.primary_key. La gema crea (id, isp_id) automáticamente.
-      t.string :topic
-      t.timestamps
-    end
-  end
+# app/models/application_record.rb
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+
+  # Habilita la herramienta, pero permanece inactiva por defecto.
+  include TenantPartition::Concerns::Partitioned
 end
 ```
 
-### 2. Capa de Infraestructura (Modelos Partition)
-
-Define modelos que hereden de `TenantPartition::Base`. Estos modelos son responsables de las operaciones DDL (Create/Drop tables). Por convención, se recomienda usar el namespace `Partition::`.
+### Opción B: Local (A la carta)
+Si prefieres no tocar `ApplicationRecord` o estás en un sistema legacy, puedes incluir el concern solo en los modelos específicos.
 
 ```ruby
-# app/models/partition/conversation.rb
-module Partition
-  class Conversation < TenantPartition::Base
-    # Hereda la configuración global (:isp_id) automáticamente.
-  end
+# app/models/conversation.rb
+class Conversation < ApplicationRecord
+  include TenantPartition::Concerns::Partitioned
+  partition_table # Activación inmediata
 end
 ```
 
-### 3. Capa de Negocio (Modelos Rails)
+---
 
-En tus modelos estándar (`ApplicationRecord`), incluye el concern `Partitioned`.
+## 📖 Referencia de Macros y Métodos
 
-**Magia de Introspección:**
-Al incluir el concern, la gema busca automáticamente si existe un modelo de infraestructura asociado (ej: `Partition::Conversation`) y hereda su configuración.
+Una vez que incluyes `TenantPartition::Concerns::Partitioned` en tu clase, obtienes acceso a las siguientes herramientas:
+
+### 1. La Macro de Activación: `partition_table`
+
+Es el interruptor de encendido. Debe llamarse al inicio de la definición del modelo.
 
 ```ruby
-# app/models/conversation.rb
 class Conversation < ApplicationRecord
-  include TenantPartition::Concerns::Partitioned
+  # Uso estándar (usa la key configurada globalmente, ej: :isp_id)
+  partition_table
 
-  # ¡Listo! Rails ahora sabe que la Primary Key es [:id, :isp_id]
-  # y aplica scopes automáticos.
+  # Uso personalizado (para modelos con keys únicas, ej: :year)
+  # partition_table key: :year
 end
 ```
 
-### 4. Orquestación (Ciclo de Vida del Tenant)
+**¿Qué hace esta macro internamente?**
+1.  Configura la **Primary Key Compuesta** (`[:id, :partition_key]`).
+2.  Registra el modelo en el sistema de mantenimiento de la gema.
+3.  Inyecta los métodos de gestión de infraestructura (ver abajo).
+4.  Agrega el scope `for_partition(value)`.
 
-Ya no necesitas crear particiones tabla por tabla. Usa la **Fachada** `TenantPartition` para gestionar la infraestructura de un tenant en **todos** los modelos registrados simultáneamente.
+### 2. Métodos de Gestión de Infraestructura (Class Methods)
 
-**Crear un nuevo Tenant (Provisioning):**
-Ideal para usar en tu `RegistrationService` o `AfterCommit` de la creación del tenant.
+Estos métodos se inyectan en tu modelo **solo después** de llamar a `partition_table`. Úsalos para gestionar el ciclo de vida de las tablas físicas.
 
-```ruby
-# En tu Service Object o Controller de registro
-def create_tenant
-  isp = Isp.create!(params)
+| Método | Descripción | Ejemplo |
+| :--- | :--- | :--- |
+| `create_partition(val)` | Crea la tabla física en Postgres (`CREATE TABLE ... PARTITION OF ...`). | `Conversation.create_partition(100)` |
+| `drop_partition(val)` | Elimina la tabla física y sus datos (`DROP TABLE ...`). | `Conversation.drop_partition(100)` |
+| `partition_table_exists?(val)` | Devuelve `true` si la tabla física existe en la BD. | `Conversation.partition_table_exists?(100)` |
+| `partition_table_name(val)` | Devuelve el nombre real de la tabla hija. | `Conversation.partition_table_name(100)` <br> *=> "conversations_isp_100"* |
 
-  # Busca TODOS los modelos particionados y crea las tablas físicas para este ID.
-  # Es idempotente: si alguna ya existe, la salta sin error.
-  TenantPartition.create!(isp.id)
-end
-```
+---
 
-**Eliminar un Tenant (Deprovisioning):**
+## 🛠 Guía de Implementación
 
-```ruby
-# Esta operación realiza DETACH + DROP de las tablas físicas.
-# ¡Es destructiva e irreversible!
-TenantPartition.destroy!(old_isp.id)
-```
+### 1. Migración de Base de Datos
 
-### 5. Generador de API (Provisioning)
+PostgreSQL necesita que la tabla padre se cree con la opción `PARTITION BY LIST`.
 
-Para facilitar la integración con sistemas externos, la gema incluye un generador que crea un controlador base con las acciones `create`, `destroy` y `show` para tus tenants.
+```ruby
+class CreateConversations < ActiveRecord::Migration[7.1]
+  def up
+    # 1. Crear la tabla padre particionada (id: false es importante)
+    create_table :conversations, id: false, options: "PARTITION BY LIST (isp_id)" do |t|
+      t.bigserial :id, null: false
+      t.integer :isp_id, null: false # Tu partition key
+
+      t.string :subject
+      t.timestamps
+    end
 
-**Uso Básico (Namespace por defecto `TenantPartition`):**
+    # 2. Definir la Primary Key Compuesta (Requerido por Postgres)
+    execute "ALTER TABLE conversations ADD PRIMARY KEY (id, isp_id);"
 
-```bash
-bundle exec rails g tenant_partition:api_controller
-# Crea: app/controllers/tenant_partition/tenant_partitions_controller.rb
-# Ruta: POST /tenant_partition/tenant_partitions
+    # 3. Crear tabla DEFAULT (Recomendado para evitar errores de inserción)
+    execute "CREATE TABLE conversations_default PARTITION OF conversations DEFAULT;"
+  end
+# ...
 ```
 
-### 6. Seguridad en Controladores
+### 2. Callbacks de Aprovisionamiento
 
-Protege tus API endpoints asegurando que siempre reciban el ID del tenant.
+Es común automatizar la creación de particiones cuando se crea un nuevo Tenant (ej. un nuevo ISP o Cliente).
 
 ```ruby
-class ApiController < ActionController::API
-  include TenantPartition::Concerns::Controller
-
-  # Valida que el request traiga el header 'X-Tenant-ID'.
-  # Devuelve 400 Bad Request si falta.
-  before_action :require_partition_key!
+# app/models/isp.rb
+class Isp < ApplicationRecord
+  after_create :provision_infrastructure
 
-  def index
-    # current_partition_id contiene el valor seguro del Header
-    @chats = Conversation.for_partition(current_partition_id).all
-    render json: @chats
+  def provision_infrastructure
+    # Método helper que crea las particiones en TODOS los modelos registrados
+    TenantPartition.create!(self.id)
   end
 end
 ```
 
-## 🛡 Mantenimiento y Recuperación
-
-TenantPartition maneja el escenario de "Race Condition" donde llegan datos *antes* de que la partición exista. Esos datos caen automáticamente en la tabla `_default`.
+---
 
-### Auditoría
+## 🧹 Mantenimiento y Datos Huérfanos
 
-Verifica si tienes datos "fugados" en las tablas default:
+Si insertas datos con un `isp_id` para el cual no has creado una partición (y tienes una tabla `DEFAULT`), los datos caerán ahí.
 
-```ruby
-# Desde consola Rails
-report = TenantPartition.audit
-# => { "Partition::Conversation" => 14, "Partition::Message" => 0 }
-```
+### Auditoría
+Verifica si tienes datos en las tablas default:
 
-O vía Rake task:
 ```bash
-bundle exec rails tenant_partition:audit
+bundle exec rake tenant_partition:audit
+# [TenantPartition] [AUDIT] Iniciando auditoría...
+# [TenantPartition] [ALERTA] Conversation: 450 registros huérfanos encontrados.
 ```
 
 ### Limpieza (Cleanup)
+Crea las particiones faltantes y mueve los datos automáticamente:
 
-Mueve los datos huérfanos a sus particiones correspondientes de forma atómica y segura.
-
-```ruby
-# Ruby API (Ideal para Jobs nocturnos)
-TenantPartition.cleanup!
-```
-
-O vía Rake task:
 ```bash
-bundle exec rails tenant_partition:cleanup
+bundle exec rake tenant_partition:cleanup
+# [TenantPartition] [FIX] Conversation: Procesando 2 tenants con datos huérfanos.
+# [TenantPartition] [MOVE] -> ID 101: 450 registros recuperados.
 ```
 
-## 📊 Observabilidad
+---
 
-Puedes suscribirte a los eventos para enviar métricas a tu sistema de monitoreo (Datadog, Prometheus, NewRelic).
+## 🛡️ Producción y Seguridad
 
-```ruby
-# config/initializers/notifications.rb
-ActiveSupport::Notifications.subscribe(/tenant_partition/) do |name, start, finish, id, payload|
-  duration = (finish - start) * 1000
-
-  case name
-  when "create.tenant_partition"
-    Rails.logger.info "📦 Partición creada: #{payload[:table]} para #{payload[:value]}"
-  when "populate.tenant_partition"
-    Rails.logger.info "🧹 Limpieza: #{payload[:count]} registros movidos en #{duration.round(2)}ms"
-  end
-end
+La gema incluye un `SafetyGuard` que impide ejecutar comandos destructivos (`drop_partition`, `destroy!`) en entorno de producción a menos que se fuerce explícitamente.
+
+Para ejecutar tareas destructivas en producción, debes setear la variable de entorno:
+
+```bash
+DISABLE_TENANT_PARTITION_GUARD=true bundle exec rake tenant_partition:destroy_tenant[123]
 ```
 
-## 📄 Licencia
+---
+
+## License
 
-Este proyecto está disponible como código abierto bajo los términos de la [Licencia MIT](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/generators/tenant_partition/api_controller_generator.rb

@@ -61,6 +61,7 @@ module TenantPartition
         # Definición de rutas explícitas apuntando al controlador generado
         route "post   '#{folder_name}/tenant_partitions', to: '#{folder_name}/tenant_partitions#create'"
         route "delete '#{folder_name}/tenant_partitions/:id', to: '#{folder_name}/tenant_partitions#destroy'"
+        route "get    '#{folder_name}/tenant_partitions/:id', to: '#{folder_name}/tenant_partitions#show'"
       end
 
       # Muestra instrucciones post-generación en la consola.

data/lib/generators/tenant_partition/templates/tenant_partitions_controller.rb.erb

@@ -2,7 +2,7 @@ module <%= @module_name %>
   class TenantPartitionsController < ApplicationController
     skip_before_action :verify_authenticity_token, raise: false
 
-    # POST /<%= @module_name.underscores %>/tenant_partitions
+    # POST /system/tenant_partitions
     def create
       partition_id = params.require(:id)
 
@@ -12,14 +12,25 @@ module <%= @module_name %>
         TenantPartition.create!(partition_id)
         render json: { message: "Tenant provisioned successfully" }, status: :created
       end
+    rescue => e
+      render json: { error: e.message }, status: :unprocessable_entity
     end
 
-    # DELETE /<%= @module_name.underscores %>/tenant_partitions/:id
+    # DELETE /system/tenant_partitions/:id
     def destroy
       partition_id = params.require(:id)
 
       TenantPartition.destroy!(partition_id)
       head :no_content
     end
+
+    # GET /system/tenant_partitions/:id
+    def show
+      if TenantPartition.exists?(params[:id])
+        render json: { active: true, id: params[:id] }, status: :ok
+      else
+        render json: { active: false }, status: :not_found
+      end
+    end
   end
 end

data/lib/tenant_partition/concerns/data_mover.rb

@@ -2,15 +2,12 @@
 
 module TenantPartition
   module Concerns
-    # Módulo encargado de la migración de datos (Backfilling) entre tablas.
-    # Se extrajo de {TenantPartition::Base} para desacoplar la lógica de movimiento de datos.
+    # Funcionalidad para mover registros desde la tabla DEFAULT hacia su partición correspondiente.
+    # Utilizado principalmente en tareas de mantenimiento y recuperación de datos.
     module DataMover
       extend ActiveSupport::Concern
 
-      # Query SQL parametrizada para el movimiento atómico (DELETE + INSERT).
-      # Se define como constante para evitar la ofensa Metrics/MethodLength de RuboCop
-      # y mejorar la performance evitando la re-asignación de memoria en cada llamada.
-      # @api private
+      # SQL optimizado para mover datos en masa (CTE + DELETE/INSERT).
       MOVE_SQL = <<~SQL.squish.freeze
         WITH moved_rows AS (
           DELETE FROM %<default>s
@@ -24,14 +21,12 @@ module TenantPartition
       SQL
       private_constant :MOVE_SQL
 
-      # Mueve registros desde la tabla DEFAULT hacia la partición actual.
-      # Utiliza transacciones por lotes para evitar bloqueos prolongados en la base de datos.
+      # Mueve registros pertenecientes a este tenant desde la tabla Default a la partición.
+      # Se ejecuta en lotes para no bloquear la base de datos.
       #
-      # @param batch_size [Integer] Cantidad de registros por transacción (Default: 5000).
-      # @return [Integer] La cantidad total de registros movidos exitosamente.
+      # @param batch_size [Integer] Tamaño del lote (default: 5000).
+      # @return [Integer] Cantidad total de registros movidos.
       def populate_from_default(batch_size: 5000)
-        return 0 unless persisted?
-
         ActiveSupport::Notifications.instrument("populate.tenant_partition", instrumentation_payload) do |evt|
           total = perform_batch_move(batch_size)
           evt[:count] = total
@@ -41,19 +36,19 @@ module TenantPartition
 
       private
 
-      # Construye el payload de datos para la instrumentación de ActiveSupport.
-      # @return [Hash] Datos del contexto de la migración.
       def instrumentation_payload
         {
-          partition_key: self.class.partition_key,
+          partition_key: self.class.partition_key_column,
           value: partition_id,
-          parent_table: self.class.parent_table
+          parent_table: self.class.table_name
         }
       end
 
-      # Ejecuta el bucle de movimiento hasta que no queden registros pendientes.
-      # @param batch_size [Integer] Tamaño del lote.
-      # @return [Integer] Total acumulado de registros movidos.
+      # Obtiene el valor del ID de partición de la instancia actual.
+      def partition_id
+        public_send(self.class.partition_key_column)
+      end
+
       def perform_batch_move(batch_size)
         total_moved = 0
         loop do
@@ -64,26 +59,18 @@ module TenantPartition
         total_moved
       end
 
-      # Ejecuta una transacción atómica para mover un solo lote de registros.
-      # @param batch_size [Integer] Tamaño del lote.
-      # @return [Integer] Cantidad de filas afectadas (cmd_tuples).
       def move_single_batch(batch_size)
         self.class.connection.transaction do
-          # Kernel#format es más rápido y seguro que la interpolación directa para templates
           sql = format(MOVE_SQL, move_query_params(batch_size))
           self.class.connection.execute(sql).cmd_tuples
         end
       end
 
-      # Prepara los parámetros para inyectar en la plantilla SQL.
-      # Se extrajo a un método separado para reducir la longitud de `move_single_batch`.
-      # @param batch_size [Integer] Tamaño del lote.
-      # @return [Hash] Parámetros formateados para Kernel#format.
       def move_query_params(batch_size)
         {
-          default: self.class.default_table,
-          parent: self.class.parent_table,
-          key: self.class.partition_key,
+          default: self.class.default_partition_table_name,
+          parent: self.class.table_name,
+          key: self.class.partition_key_column,
           val: partition_id,
           batch_size: batch_size
         }

data/lib/tenant_partition/concerns/partitioned.rb

@@ -1,63 +1,138 @@
 # frozen_string_literal: true
 
+require_relative "data_mover"
+
 module TenantPartition
   module Concerns
-    # Concern para modelos Rails (ApplicationRecord).
-    # Configura automáticamente las claves primarias compuestas y scopes.
+    # Concern principal para dotar a un modelo ActiveRecord de capacidades de particionamiento.
+    #
+    # Al incluir este concern en ApplicationRecord, los modelos obtienen acceso a la macro
+    # {.partition_table}, la cual activa la lógica de partición, configura la clave primaria
+    # compuesta y añade métodos de gestión de tablas (DDL).
     module Partitioned
       extend ActiveSupport::Concern
 
-      included do
-        TenantPartition::Concerns::Partitioned.configure_model(self)
-      end
-
       class_methods do
-        # Intercepta la herencia para autoconfigurar subclases.
-        def inherited(subclass)
-          super
-          TenantPartition::Concerns::Partitioned.configure_model(subclass)
+        # Macro para activar el particionamiento en el modelo actual.
+        #
+        # @example Activar partición por ISP
+        #   class Conversation < ApplicationRecord
+        #     partition_table key: :isp_id
+        #   end
+        #
+        # @param key [Symbol, nil] La columna clave de partición. Si es nil, usa la global.
+        # @return [void]
+        def partition_table(key: nil)
+          resolved_key = key || TenantPartition.configuration.partition_key
+
+          # Guardamos la key en una variable de instancia de clase para acceso rápido
+          @partition_key_column = resolved_key
+
+          # Registrar este modelo en el sistema
+          TenantPartition.register_model(self)
+
+          # Configurar Primary Key Compuesta (Soporte Rails 7.1+)
+          self.primary_key = [:id, resolved_key]
+
+          # Inyectar Scopes Automáticos
+          scope :for_partition, ->(val) { where(resolved_key => val) }
+
+          # Inyectar lógica de infraestructura y movimiento de datos
+          extend ManagementMethods
+          include TenantPartition::Concerns::DataMover
         end
 
-        # Permite definir manualmente la clave de partición para este modelo.
-        # @param key [Symbol] Nombre de la columna.
-        def partitioned_by(key)
-          TenantPartition::Concerns::Partitioned.apply_configuration(self, key)
+        # Devuelve el nombre de la columna usada para particionar este modelo.
+        # @return [Symbol]
+        def partition_key_column
+          @partition_key_column
         end
       end
 
-      # Configura el modelo detectando la clave de partición adecuada.
-      # @api private
-      # @param klass [Class] El modelo a configurar.
-      def self.configure_model(klass)
-        return if klass.respond_to?(:abstract_class?) && klass.abstract_class?
+      # Métodos de gestión de infraestructura (DDL) inyectados como métodos de clase.
+      module ManagementMethods
+        # Crea físicamente la partición en la base de datos para un valor dado.
+        #
+        # @param value [String, Integer] El valor del tenant (ej: ID del ISP).
+        # @return [void]
+        # @raise [ActiveRecord::StatementInvalid] Si falla la ejecución SQL.
+        def create_partition(value)
+          payload = create_partition_payload(value)
 
-        key_to_use = resolve_partition_key(klass)
-        apply_configuration(klass, key_to_use) if key_to_use.present?
-      end
+          ActiveSupport::Notifications.instrument("create.tenant_partition", payload) do
+            execute_create_partition_sql(value)
+          end
+        end
 
-      # Resuelve la clave de partición mediante introspección o configuración global.
-      # @api private
-      # @param klass [Class] El modelo a inspeccionar.
-      # @return [Symbol, nil] La clave encontrada.
-      def self.resolve_partition_key(klass)
-        infra_class_name = "Partition::#{klass.name}"
-        infra_class = infra_class_name.safe_constantize
+        # Elimina (DROP) la partición asociada al valor dado.
+        # Realiza un DETACH primero para seguridad y luego DROP.
+        #
+        # @param value [String, Integer] El valor del tenant.
+        # @return [void]
+        def drop_partition(value)
+          partition_name = partition_table_name(value)
 
-        # CORRECCIÓN: respond_to? es seguro en nil, no requiere safe navigation (&.)
-        return infra_class.partition_key if infra_class.respond_to?(:partition_key)
+          return unless partition_table_exists?(value)
 
-        TenantPartition.configuration&.partition_key
-      end
+          connection.transaction do
+            connection.execute("ALTER TABLE #{table_name} DETACH PARTITION #{partition_name};")
+            connection.execute("DROP TABLE IF EXISTS #{partition_name};")
+          end
+        end
 
-      # Aplica la configuración de CPK y scopes al modelo.
-      # @api private
-      # @param klass [Class] El modelo.
-      # @param key [Symbol] La clave de partición.
-      def self.apply_configuration(klass, key)
-        return if klass.primary_key.is_a?(Array) && klass.primary_key.include?(key.to_s)
+        # Genera el nombre de la tabla física para una partición específica.
+        #
+        # @param value [Object] El valor del tenant.
+        # @return [String] Nombre de la tabla (ej: 'conversations_isp_1').
+        def partition_table_name(value)
+          sanitized_value = value.to_s.gsub("-", "_")
+          suffix = partition_key_column.to_s.gsub("_id", "")
 
-        klass.primary_key = [:id, key]
-        klass.scope :for_partition, ->(value) { where(key => value) }
+          # Formato: nombre_tabla_sufijo_valor
+          "#{table_name}_#{suffix}_#{sanitized_value}"
+        end
+
+        # Verifica si la tabla de la partición existe en el catálogo de PostgreSQL.
+        #
+        # @param value [Object] El valor del tenant.
+        # @return [Boolean]
+        def partition_table_exists?(value)
+          child_table = partition_table_name(value)
+
+          sql = <<~SQL.squish
+            SELECT 1 FROM pg_class c
+            JOIN pg_inherits i ON c.oid = i.inhrelid
+            JOIN pg_class p ON i.inhparent = p.oid
+            WHERE p.relname = '#{table_name}' AND c.relname = '#{child_table}';
+          SQL
+
+          connection.execute(sql).any?
+        end
+
+        # Nombre de la tabla DEFAULT (para valores que no caen en ninguna partición).
+        # @return [String]
+        def default_partition_table_name
+          "#{table_name}_default"
+        end
+
+        private
+
+        def create_partition_payload(value)
+          {
+            partition_key: partition_key_column,
+            value: value,
+            parent_table: table_name
+          }
+        end
+
+        def execute_create_partition_sql(value)
+          table_name_for_partition = partition_table_name(value)
+          sql = <<~SQL.squish
+            CREATE TABLE IF NOT EXISTS #{table_name_for_partition}
+            PARTITION OF #{table_name} FOR VALUES IN ('#{value}');
+          SQL
+          connection.execute(sql)
+        end
       end
     end
   end

data/lib/tenant_partition/maintenance.rb

@@ -1,79 +1,76 @@
 # frozen_string_literal: true
 
 module TenantPartition
-  # Módulo Mixin que agrega capacidades de mantenimiento (Auditoría y Limpieza)
-  # a la fachada principal.
+  # Módulo de utilidades para el mantenimiento de la salud de las particiones.
+  # Permite auditar tablas DEFAULT en busca de registros huérfanos y moverlos.
   module Maintenance
-    # Audita todas las tablas DEFAULT del sistema buscando registros huérfanos.
-    # Un registro huérfano es aquel que cayó en la tabla default porque su partición no existía.
+    # Audita todas las tablas particionadas y cuenta registros en la tabla DEFAULT.
     #
-    # @return [Hash{String => Integer}] Reporte con nombre del modelo y cantidad de huérfanos.
+    # @return [Hash{String => Integer}] Reporte con el conteo de huérfanos por modelo.
     def audit
-      ensure_models_loaded!
-      log_info "AUDIT", "Iniciando auditoría de tablas DEFAULT..."
+      TenantPartition.send(:ensure_models_loaded!)
+      TenantPartition.log_info "AUDIT", "Iniciando auditoría de tablas DEFAULT..."
 
-      partitionable_models.each_with_object({}) do |model, report|
+      TenantPartition.partitionable_models.each_with_object({}) do |model, report|
         count = count_default_rows(model)
         report[model.name] = count
         log_audit_result(model, count)
       end
     end
 
-    # Ejecuta el proceso de limpieza global.
-    # Identifica registros huérfanos y los mueve a sus particiones correspondientes.
+    # Ejecuta el proceso de limpieza: busca huérfanos y los mueve a su partición correspondiente.
+    # Si la partición no existe, lanza un error en el log.
     #
     # @return [void]
     def cleanup!
-      ensure_models_loaded!
-      key = configuration.partition_key
-      log_info "CLEANUP", "Iniciando proceso de limpieza global..."
+      TenantPartition.log_info "CLEANUP", "Iniciando proceso de limpieza global..."
 
-      partitionable_models.each do |model|
-        process_cleanup_for_model(model, key)
+      TenantPartition.partitionable_models.each do |model|
+        # Usamos la key específica del modelo por si fue configurada localmente
+        model_key = model.partition_key_column
+        process_cleanup_for_model(model, model_key)
       end
     end
 
     private
 
-    # Registra el resultado de una auditoría en el log.
     def log_audit_result(model, count)
       if count.positive?
-        log_warn "ALERTA", "#{model.name}: #{count} registros huérfanos encontrados."
+        TenantPartition.log_warn "ALERTA", "#{model.name}: #{count} registros huérfanos encontrados."
       else
-        log_info "OK", "#{model.name}: Tabla default limpia."
+        TenantPartition.log_info "OK", "#{model.name}: Tabla default limpia."
       end
     end
 
-    # Orquesta la limpieza para un modelo específico.
     def process_cleanup_for_model(model, key)
       orphan_ids = fetch_orphan_ids(model, key)
-      return log_info("OK", "#{model.name}: Sin datos huérfanos.") if orphan_ids.empty?
+      return TenantPartition.log_info("OK", "#{model.name}: Sin datos huérfanos.") if orphan_ids.empty?
 
-      log_warn "FIX", "#{model.name}: Procesando #{orphan_ids.count} tenants con datos huérfanos."
+      TenantPartition.log_warn "FIX", "#{model.name}: Procesando #{orphan_ids.count} tenants con datos huérfanos."
       orphan_ids.each { |id| move_orphans(model, id) }
     end
 
-    # Mueve los huérfanos de un tenant específico.
     def move_orphans(model, id)
-      partition = model.find(id)
-      if partition
-        moved = partition.populate_from_default
-        log_info "MOVE", "  -> ID #{id}: #{moved} registros recuperados."
+      # Verificamos si la tabla destino existe antes de intentar mover
+      if model.partition_table_exists?(id)
+        # Instanciamos el modelo solo para usar el DataMover
+        instance = model.new(model.partition_key_column => id)
+
+        moved = instance.populate_from_default
+        TenantPartition.log_info "MOVE", "  -> ID #{id}: #{moved} registros recuperados."
       else
-        log_error "ERROR", "  -> ID #{id}: La partición física no existe. Cree el tenant primero."
+        TenantPartition.log_error "ERROR", "  -> ID #{id}: La partición física no existe. Cree el tenant primero."
       end
     end
 
-    # Cuenta las filas en la tabla default de un modelo.
     def count_default_rows(model)
-      model.connection.select_value("SELECT count(*) FROM #{model.default_table}").to_i
+      model.connection.select_value("SELECT count(*) FROM #{model.default_partition_table_name}").to_i
     rescue ActiveRecord::StatementInvalid
       0
     end
 
-    # Obtiene los IDs únicos de los registros atrapados en la tabla default.
     def fetch_orphan_ids(model, key)
-      sql = "SELECT DISTINCT #{key} FROM #{model.default_table} WHERE #{key} IS NOT NULL"
+      sql = "SELECT DISTINCT #{key} FROM #{model.default_partition_table_name} WHERE #{key} IS NOT NULL"
       model.connection.execute(sql).map { |r| r[key.to_s] }
     rescue ActiveRecord::StatementInvalid
       []

data/lib/tenant_partition/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TenantPartition
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

data/lib/tenant_partition.rb

@@ -7,7 +7,6 @@ require "active_support/all"
 require_relative "tenant_partition/version"
 require_relative "tenant_partition/configuration"
 require_relative "tenant_partition/safety_guard"
-require_relative "tenant_partition/base"
 require_relative "tenant_partition/maintenance"
 require_relative "tenant_partition/concerns/partitioned"
 require_relative "tenant_partition/concerns/controller"
@@ -15,29 +14,62 @@ require_relative "tenant_partition/concerns/controller"
 require_relative "tenant_partition/railtie" if defined?(Rails)
 
 # Fachada principal para la gestión y orquestación de particionamiento en PostgreSQL.
-# Centraliza la configuración, creación de particiones y mantenimiento.
+# Permite configurar la gema y ejecutar comandos globales de creación/eliminación de tenants.
 module TenantPartition
   class Error < StandardError; end
 
-  # Incorpora las funcionalidades de Auditoría y Limpieza.
   extend Maintenance
 
   class << self
-    # @return [TenantPartition::Configuration] Objeto de configuración global.
+    # @return [TenantPartition::Configuration] la configuración actual.
     attr_accessor :configuration
 
-    # Bloque de configuración e inicialización.
-    # @yieldparam [TenantPartition::Configuration] config
+    # Array para almacenar los modelos que han activado el particionamiento.
+    # @return [Array<Class>] Lista de clases ActiveRecord registradas.
+    def registered_models
+      @registered_models ||= []
+    end
+
+    # Registra un modelo como particionado.
+    # Método llamado automáticamente por el concern {TenantPartition::Concerns::Partitioned}.
+    #
+    # @api private
+    # @param model [Class] La clase del modelo a registrar.
+    # @return [Array<Class>] La lista actualizada de modelos.
+    def register_model(model)
+      registered_models << model
+      registered_models.uniq!
+    end
+
+    # Devuelve la lista de modelos particionados activos en la aplicación.
+    # @return [Array<Class>] Lista de modelos.
+    def partitionable_models
+      registered_models
+    end
+
+    # Bloque de configuración global para la gema.
+    #
+    # @example Configurar el ISP ID como clave
+    #   TenantPartition.configure do |config|
+    #     config.partition_key = :isp_id
+    #   end
+    #
+    # @yield [configuration] Objeto de configuración.
+    # @return [void]
     def configure
       self.configuration ||= Configuration.new
       yield(configuration)
       SafetyGuard.validate!
     end
 
-    # Crea las particiones físicas para un tenant en todos los modelos registrados.
-    # @param partition_id [String, Integer] Identificador del tenant.
+    # Crea la infraestructura de particiones (tablas) para un tenant específico.
+    # Itera sobre todos los modelos registrados y crea su tabla particionada correspondiente.
+    #
+    # @param partition_id [Integer, String] El identificador del tenant (ej. ISP ID).
+    # @return [void]
     def create!(partition_id)
       ensure_models_loaded!
+
       log_info "CREATE", "Iniciando aprovisionamiento para ID: #{partition_id}"
 
       partitionable_models.each do |model|
@@ -45,10 +77,14 @@ module TenantPartition
       end
     end
 
-    # Elimina irreversiblemente las particiones y datos de un tenant.
-    # @param partition_id [String, Integer] Identificador del tenant.
+    # Destruye la infraestructura de particiones para un tenant específico.
+    # ¡CUIDADO! Esto elimina físicamente las tablas y sus datos.
+    #
+    # @param partition_id [Integer, String] El identificador del tenant.
+    # @return [void]
     def destroy!(partition_id)
       ensure_models_loaded!
+
       log_info "DESTROY", "Eliminando infraestructura para ID: #{partition_id}"
 
       partitionable_models.each do |model|
@@ -57,57 +93,44 @@ module TenantPartition
     end
 
     # Verifica si existe infraestructura creada para un tenant.
-    # @param partition_id [String, Integer] Identificador del tenant.
-    # @return [Boolean] true si existe al menos una tabla particionada.
+    #
+    # @param partition_id [Integer, String] El identificador del tenant.
+    # @return [Boolean] true si al menos un modelo tiene la tabla creada.
     def exists?(partition_id)
-      ensure_models_loaded!
-      partitionable_models.any? { |model| model.exists?(partition_id) }
+      partitionable_models.any? { |model| model.partition_table_exists?(partition_id) }
     end
 
-    # --- Shared Helpers (Accesibles por Maintenance) ---
-
-    # Fuerza la carga de los modelos de partición en entornos con Lazy Loading (Dev).
-    def ensure_models_loaded!
-      return unless defined?(Rails)
-
-      partition_dir = Rails.root.join("app/models/partition")
-      return unless Dir.exist?(partition_dir)
-
-      Dir[partition_dir.join("**/*.rb")].each { |file| require_dependency file }
-    end
-
-    # Retorna todas las subclases de TenantPartition::Base cargadas en memoria.
-    # @return [Array<Class>] Lista de clases de modelos.
-    def partitionable_models
-      ObjectSpace.each_object(Class).select { |klass| klass < TenantPartition::Base }
-    end
-
-    # --- Logging ---
-
+    # @api private
     def log_info(tag, msg)  = logger&.info(format_log(tag, msg))
+    # @api private
     def log_warn(tag, msg)  = logger&.warn(format_log(tag, msg))
+    # @api private
     def log_error(tag, msg) = logger&.error(format_log(tag, msg))
+
+    private
+
     def format_log(tag, msg) = "[TenantPartition] [#{tag}] #{msg}"
     def logger = (defined?(Rails) ? Rails.logger : Logger.new($stdout))
 
-    private
+    def ensure_models_loaded!
+      return unless defined?(Rails) && !Rails.configuration.eager_load
+
+      Rails.application.eager_load!
+    end
 
     def process_creation(model, partition_id)
-      if model.exists?(partition_id)
+      if model.partition_table_exists?(partition_id)
         log_info "SKIP", "#{model.name}: La partición ya existe."
       else
-        model.create(partition_id)
+        model.create_partition(partition_id)
         log_info "OK", "#{model.name}: Partición creada exitosamente."
       end
     end
 
     def process_destruction(model, partition_id)
-      if model.exists?(partition_id)
-        if model.find(partition_id).destroy
-          log_info "DROP", "#{model.name}: Partición eliminada."
-        else
-          log_error "FAIL", "#{model.name}: No se pudo eliminar la partición."
-        end
+      if model.partition_table_exists?(partition_id)
+        model.drop_partition(partition_id)
+        log_info "DROP", "#{model.name}: Partición eliminada."
       else
         log_info "SKIP", "#{model.name}: No existe partición para borrar."
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tenant_partition
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - gabriel
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-03 00:00:00.000000000 Z
+date: 2026-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -17,9 +17,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.1'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -27,9 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.1'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '9.0'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -37,9 +31,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.1'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -47,9 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '7.1'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '9.0'
 description: Framework de infraestructura para Rails 7.1+ que automatiza el particionamiento
   nativo (List Partitioning). Incluye soporte para Composite Primary Keys, orquestación
   de tenants y migraciones zero-downtime.
@@ -67,7 +55,6 @@ files:
 - lib/generators/tenant_partition/templates/README
 - lib/generators/tenant_partition/templates/tenant_partitions_controller.rb.erb
 - lib/tenant_partition.rb
-- lib/tenant_partition/base.rb
 - lib/tenant_partition/concerns/controller.rb
 - lib/tenant_partition/concerns/data_mover.rb
 - lib/tenant_partition/concerns/partitioned.rb

data/lib/tenant_partition/base.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "concerns/data_mover"
-
-module TenantPartition
-  # Clase base abstracta para definir modelos de infraestructura de particionamiento.
-  # Hereda de esta clase para habilitar operaciones DDL (Create/Drop) sobre tus tablas particionadas.
-  #
-  # @abstract
-  class Base
-    include ActiveModel::Model
-    include ActiveModel::Attributes
-    include TenantPartition::Concerns::DataMover
-
-    # Hook de herencia para definir automáticamente el atributo de partición en las subclases.
-    # @param subclass [Class] La clase que hereda.
-    def self.inherited(subclass)
-      super
-      key = TenantPartition.configuration&.partition_key
-      subclass.attribute key if key
-    end
-
-    class << self
-      attr_writer :parent_table, :prefix, :default_table
-
-      # @return [String] Nombre de la tabla padre (ej: 'conversations').
-      def parent_table
-        @parent_table ||= name.demodulize.underscore.pluralize
-      end
-
-      # @return [Symbol] Clave de partición configurada (ej: :isp_id).
-      # @raise [TenantPartition::Error] Si no hay configuración global ni local.
-      def partition_key
-        @partition_key ||= TenantPartition.configuration&.partition_key ||
-                           raise(TenantPartition::Error, "Clave de partición no configurada.")
-      end
-
-      # Define manualmente la clave de partición para esta clase, sobrescribiendo la global.
-      # @param value [Symbol] Nombre de la columna.
-      def partition_key=(value)
-        @partition_key = value
-        attribute value
-      end
-
-      # @return [String] Prefijo para las tablas particionadas (ej: 'conversations_isp').
-      def prefix
-        @prefix ||= "#{parent_table}_#{partition_key.to_s.gsub("_id", "")}"
-      end
-
-      # @return [String] Nombre de la tabla DEFAULT.
-      def default_table
-        @default_table ||= "#{parent_table}_default"
-      end
-
-      # @return [ActiveRecord::ConnectionAdapters::PostgreSQLAdapter] Conexión activa a la DB.
-      def connection
-        ActiveRecord::Base.connection
-      end
-
-      # Crea una nueva partición física en la base de datos.
-      # @param value [String, Integer] El valor discriminador del tenant (ej: UUID).
-      # @return [TenantPartition::Base] Una instancia representando la nueva partición.
-      def create(value)
-        payload = { partition_key: partition_key, value: value, table: parent_table }
-
-        ActiveSupport::Notifications.instrument("create.tenant_partition", payload) do
-          name = partition_name(value)
-          sql = "CREATE TABLE IF NOT EXISTS #{name} PARTITION OF #{parent_table} FOR VALUES IN ('#{value}');"
-          connection.execute(sql)
-          new(partition_key => value)
-        end
-      end
-
-      # Genera el nombre físico de la tabla particionada, sanitizando el valor.
-      # @param value [Object] Valor del tenant.
-      # @return [String] Nombre de la tabla (ej: 'conversations_isp_123').
-      def partition_name(value)
-        sanitized = value.to_s.gsub("-", "_")
-        "#{prefix}_#{sanitized}"
-      end
-
-      # Verifica si la tabla particionada existe físicamente en el catálogo de PostgreSQL.
-      # @param value [Object] Valor del tenant.
-      # @return [Boolean] true si la tabla existe.
-      def exists?(value)
-        name = partition_name(value)
-        sql = <<~SQL.squish
-          SELECT 1 FROM pg_class c
-          JOIN pg_inherits i ON c.oid = i.inhrelid
-          JOIN pg_class p ON i.inhparent = p.oid
-          WHERE p.relname = '#{parent_table}' AND c.relname = '#{name}';
-        SQL
-        connection.execute(sql).any?
-      end
-
-      # Busca una partición existente.
-      # @param value [Object] Valor del tenant.
-      # @return [TenantPartition::Base, nil] Instancia si existe, nil si no.
-      def find(value)
-        new(partition_key => value) if exists?(value)
-      end
-    end
-
-    # --- Métodos de Instancia ---
-
-    # @return [Object] Valor del ID de partición de esta instancia.
-    def partition_id
-      public_send(self.class.partition_key)
-    end
-
-    # @return [String] Nombre de la tabla física correspondiente a esta instancia.
-    def partition_table_name
-      self.class.partition_name(partition_id)
-    end
-
-    # @return [Boolean] Si la partición está persistida en base de datos.
-    def persisted?
-      self.class.exists?(partition_id)
-    end
-
-    # Elimina la partición física de la base de datos (DETACH + DROP).
-    # @return [Boolean] true si la eliminación fue exitosa.
-    def destroy
-      return false unless persisted?
-
-      p_name = partition_table_name
-      p_table = self.class.parent_table
-
-      self.class.connection.transaction do
-        self.class.connection.execute("ALTER TABLE #{p_table} DETACH PARTITION #{p_name};")
-        self.class.connection.execute("DROP TABLE IF EXISTS #{p_name};")
-      end
-      true
-    rescue ActiveRecord::StatementInvalid
-      false
-    end
-  end
-end