Method execute_ddl

src/query/extended.rs:5454–5667

(
        framed: &mut Framed<T, crate::protocol::PostgresCodec>,
        db: &Arc<DbHandler>,
        session: &Arc<SessionState>,
        query: &str,
    )

    }
    
    async fn execute_ddl<T>(
        framed: &mut Framed<T, crate::protocol::PostgresCodec>,
        db: &Arc<DbHandler>,
        session: &Arc<SessionState>,
        query: &str,
    ) -> Result<(), PgSqliteError>
    where
        T: tokio::io::AsyncRead + tokio::io::AsyncWrite + Unpin,
    {
        use crate::ddl::EnumDdlHandler;
        
        // Check if this is an ENUM DDL statement first
        if EnumDdlHandler::is_enum_ddl(query) {
            // ENUM DDL needs special handling through direct SQL execution
            // Parse and execute the ENUM DDL as SQL statements
            let enum_error = PgSqliteError::Protocol(
                "ENUM DDL is not supported in the current per-session connection mode. \
                Please create ENUMs before establishing connections.".to_string()
            );
            return Err(enum_error);
        }
        
        // Handle CREATE TABLE translation
        if query_starts_with_ignore_case(query, "CREATE TABLE") {
            // Use translator with connection for ENUM support
            let (sqlite_sql, type_mappings, enum_columns, array_columns) = db.with_session_connection(&session.id, |conn| {
                let result = crate::translator::CreateTableTranslator::translate_with_connection_full(query, Some(conn))
                    .map_err(|e| rusqlite::Error::SqliteFailure(
                        rusqlite::ffi::Error::new(rusqlite::ffi::SQLITE_ERROR),
                        Some(format!("CREATE TABLE translation failed: {e}"))
                    ))?;
                
                Ok((result.sql, result.type_mappings, result.enum_columns, result.array_columns))
            }).await
            .map_err(|e| PgSqliteError::Protocol(format!("Failed to translate CREATE TABLE: {e}")))?;
            
            // Execute the translated CREATE TABLE
            let cached_conn = Self::get_or_cache_connection(session, db).await;
            db.execute_with_session_cached(&sqlite_sql, &session.id, cached_conn.as_ref()).await?;
            
            // Store the type mappings if we have any
            debug!("Type mappings count: {}", type_mappings.len());
            if !type_mappings.is_empty() {
                // Extract table name from query
                if let Some(table_name) = extract_table_name_from_create(query) {
                    // Initialize the metadata table if it doesn't exist
                    let init_query = "CREATE TABLE IF NOT EXISTS __pgsqlite_schema (
                        table_name TEXT NOT NULL,
                        column_name TEXT NOT NULL,
                        pg_type TEXT NOT NULL,
                        sqlite_type TEXT NOT NULL,
                        PRIMARY KEY (table_name, column_name)
                    )";
                    let cached_conn = Self::get_or_cache_connection(session, db).await;
                    let _ = db.execute_with_session_cached(init_query, &session.id, cached_conn.as_ref()).await;
                    
                    // Store each type mapping and numeric constraints
                    for (full_column, type_mapping) in type_mappings {