WordPress is a highly flexible platform, but sometimes its default approach using custom post types (CPTs) may not be the best fit for specific applications. If you’re building a fully custom solution that relies solely on custom database tables rather than CPTs, you need an alternative method to generate front-end pages dynamically. In this article, we’ll explore how to achieve that using a custom approach.

Why Avoid Custom Post Types (CPTs)?

WordPress’s CPTs work well for many applications, but they come with some limitations:

• Performance issues: When dealing with a large volume of data, WordPress’s wp_posts and wp_postmeta tables can become bloated and slow.
• Custom data structure: CPTs force you to store data in a predefined format, which may not be efficient for highly structured or relational data.
• Complex queries: Retrieving meta fields often requires multiple database queries, impacting performance.

By using custom tables, you have full control over your data structure, leading to better performance and flexibility.

Setting Up Custom Tables

Before we can generate front-end pages dynamically, we need a proper database structure. Below is an example of creating a custom table to store questions.

Creating the Database Table

Use the following code inside your theme’s functions.php file or a custom plugin:

function create_custom_questions_table() {
    global $wpdb;
    $table_name = $wpdb->prefix . 'custom_questions';
    
    $charset_collate = $wpdb->get_charset_collate();
    
    $sql = "CREATE TABLE $table_name (
        id BIGINT(20) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
        question_text TEXT NOT NULL,
        slug VARCHAR(255) NOT NULL UNIQUE,
        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
    ) $charset_collate;";
    
    require_once(ABSPATH . 'wp-admin/includes/upgrade.php');
    dbDelta($sql);
}

register_activation_hook(__FILE__, 'create_custom_questions_table');

This creates a table called wp_custom_questions with an ID, question text, a unique slug for URL handling, and a timestamp.

Inserting and Retrieving Data

To insert data, use the following:

function insert_custom_question($question_text) {
    global $wpdb;
    $table_name = $wpdb->prefix . 'custom_questions';
    
    $slug = sanitize_title($question_text);
    
    $wpdb->insert(
        $table_name,
        [
            'question_text' => $question_text,
            'slug' => $slug
        ],
        ['%s', '%s']
    );
}

To retrieve a question by slug:

function get_custom_question_by_slug($slug) {
    global $wpdb;
    $table_name = $wpdb->prefix . 'custom_questions';
    
    return $wpdb->get_row($wpdb->prepare("SELECT * FROM $table_name WHERE slug = %s", $slug));
}

Generating Front-End Pages Dynamically

Since we’re not using CPTs, we need a custom method to handle dynamic URLs.

Step 1: Rewrite Rules

We must register a rewrite rule to allow WordPress to recognize custom question pages.

function custom_question_rewrite_rule() {
    add_rewrite_rule('^question/([^/]*)/?', 'index.php?custom_question_slug=$matches[1]', 'top');
}
add_action('init', 'custom_question_rewrite_rule');

This tells WordPress to route any URL like example.com/question/sample-question to an internal query variable called custom_question_slug.

Step 2: Add Query Variable

function custom_query_vars($vars) {
    $vars[] = 'custom_question_slug';
    return $vars;
}
add_filter('query_vars', 'custom_query_vars');

This ensures that custom_question_slug is recognized by WordPress.

Step 3: Create a Custom Template Loader

Now, we need to create a template that will handle the dynamic page rendering.

function load_custom_question_template($template) {
    global $wp_query;
    
    if (isset($wp_query->query_vars['custom_question_slug'])) {
        return get_template_directory() . '/custom-question-template.php';
    }
    return $template;
}
add_filter('template_include', 'load_custom_question_template');

Step 4: Create the Template File

Create a file called custom-question-template.php in your theme directory:

<?php
get_header();

if (get_query_var('custom_question_slug')) {
    $slug = get_query_var('custom_question_slug');
    $question = get_custom_question_by_slug($slug);
    
    if ($question) {
        echo '<h1>' . esc_html($question->question_text) . '</h1>';
    } else {
        echo '<h1>Question Not Found</h1>';
    }
}

get_footer();
?>

Flushing Rewrite Rules

Whenever you add or modify rewrite rules, you must flush them. Run this once after adding the rewrite rule:

flush_rewrite_rules();

You can place it in an activation hook:

register_activation_hook(__FILE__, 'flush_rewrite_rules');

Adding Pagination and SEO Optimization

To enhance user experience and SEO, consider implementing pagination and metadata.

Pagination Example

$paged = get_query_var('paged') ? get_query_var('paged') : 1;
$limit = 10;
$offset = ($paged - 1) * $limit;

$questions = $wpdb->get_results($wpdb->prepare("SELECT * FROM $table_name LIMIT %d OFFSET %d", $limit, $offset));

Adding Metadata for SEO

Use wp_head action to insert metadata dynamically:

function add_custom_meta_tags() {
    if (get_query_var('custom_question_slug')) {
        $slug = get_query_var('custom_question_slug');
        $question = get_custom_question_by_slug($slug);
        if ($question) {
            echo '<meta name="description" content="' . esc_attr($question->question_text) . '" />';
        }
    }
}
add_action('wp_head', 'add_custom_meta_tags');

Conclusion

Using custom tables in WordPress without CPTs offers greater flexibility and efficiency, especially for handling large datasets. By implementing custom database tables, rewrite rules, and template loading techniques, you can dynamically generate front-end pages while maintaining optimal performance.

This approach allows you to tailor the WordPress experience to your specific needs while leveraging its robust ecosystem.