TNTSearch

https://github.com/teamtnt/tntsearch
Admin
TNTSearch is a full-text search engine written entirely in PHP with support for fuzzy search,...
Tokens:41,678
Snippets:508
Trust Score:9.3
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Execute a search query

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Example of performing a search and iterating through the returned results.

```php
$results = $tnt->search('romeo juliet', 20);
echo "Found " . $results['hits'] . " documents\n";
foreach ($results['ids'] as $docId) {
    echo "Doc ID: $docId, Score: " . $results['docScores'][$docId] . "\n";
}
```

--------------------------------

### Verify and Install PDO Drivers

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/errors.md

Check if required PDO drivers are enabled in the PHP environment and install them if missing.

```bash
# For SQLite:
php -m | grep pdo_sqlite
# If not listed, install: apt-get install php-sqlite3

# For MySQL:
php -m | grep pdo_mysql
# If not listed, install: apt-get install php-mysql

# Verify in CLI vs web:
php -r "new PDO('sqlite::memory:');"  # CLI
# Then test in web context (may be different PHP version or config)
```

--------------------------------

### Catch InvalidEngineException

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/errors.md

Example of how to handle the InvalidEngineException when loading a configuration.

```php
use TeamTNT\TNTSearch\Exceptions\InvalidEngineException;

try {
    $tnt->loadConfig($config);
} catch (InvalidEngineException $e) {
    echo "Invalid search engine: " . $e->getMessage();
}
```

--------------------------------

### Highlighting usage examples

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Demonstrates basic and advanced highlighting with custom tags and options.

```php
$title = 'The tragedy of Romeo and Juliet';
$html = $tnt->highlight($title, 'romeo juliet', 'em');
// The tragedy of <em>Romeo</em> and <em>Juliet</em>

$html = $tnt->highlight($title, 'romeo juliet', 'mark', [
    'wholeWord' => false,
    'tagOptions' => ['class' => 'search-term']
]);
// The tragedy of <mark class="search-term">Romeo</mark> and <mark class="search-term">Juliet</mark>
```

--------------------------------

### Use EdgeNgramTokenizer

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Tokenizers.md

Example of tokenizing a string using the EdgeNgramTokenizer.

```php
$tokenizer = new EdgeNgramTokenizer();
$tokens = $tokenizer->tokenize('hello');
// Returns: ['h', 'he', 'hel', 'hell', 'hello']
```

--------------------------------

### Handle Index Creation Errors

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Example of an exception thrown when the storage directory is not writable.

```php
$tnt->loadConfig(['storage' => '/readonly/storage/']);
$indexer = $tnt->createIndex('articles.index'); // throws if storage not writable
```

--------------------------------

### GermanStemmer Usage Examples

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Stemmers.md

Demonstrates word stemming for German language inputs.

```php
GermanStemmer::stem('Häuser');   // 'haus' (houses → house)
GermanStemmer::stem('laufen');   // 'lauf' (run)
GermanStemmer::stem('Schönheit');// 'schönheit' (beauty)
```

--------------------------------

### Use NGramTokenizer

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Tokenizers.md

Examples of tokenizing strings with default and custom n-gram length configurations.

```php
$tokenizer = new NGramTokenizer();
$tokens = $tokenizer->tokenize('hello');
// With defaults (minGram=3, maxGram=4):
// Returns: ['hel', 'ell', 'llo', 'hell', 'ello']

// Customize:
$tokenizer->minGram = 2;
$tokenizer->maxGram = 3;
$tokens = $tokenizer->tokenize('hello');
// Returns: ['he', 'el', 'll', 'lo', 'hel', 'ell', 'llo']
```

--------------------------------

### FrenchStemmer Usage Examples

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Stemmers.md

Demonstrates word stemming for French language inputs.

```php
FrenchStemmer::stem('courir');     // 'cour' (to run)
FrenchStemmer::stem('rapidement'); // 'rapid' (quickly)
```

--------------------------------

### RussianStemmer Usage Examples

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Stemmers.md

Demonstrates word stemming for Russian language inputs.

```php
RussianStemmer::stem('бежать');    // 'беж' (to run)
RussianStemmer::stem('быстро');    // 'быст' (quickly)
```

--------------------------------

### Tokenize text with ProductTokenizer

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Tokenizers.md

Example usage of the ProductTokenizer to split a hyphenated string into an array of tokens.

```php
$tokenizer = new ProductTokenizer();
$tokens = $tokenizer->tokenize('PROD-2024-001-RED-SMALL');
// Returns: ['prod', '2024', '001', 'red', 'small']
```

--------------------------------

### Snippet usage example

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Demonstrates extracting a snippet of a specific length from a text block.

```php
$snippet = $tnt->snippet('romeo', $articleText, 200);
// ...in the tale of Romeo and Juliet, star-crossed lovers...
```

--------------------------------

### Triggering PDOException

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/errors.md

Examples of database configuration or query errors that result in a PDOException.

```php
$tnt->loadConfig([
    'driver'   => 'mysql',
    'host'     => 'nonexistent.host',
    'database' => 'mydb',
    'username' => 'user',
    'password' => 'pass',
    'storage'  => __DIR__ . '/storage/',
]);

$indexer = $tnt->createIndex('articles.index');
$indexer->query('SELECT id, title FROM articles');
$indexer->run(); // throws PDOException: connection failed

// Or:
$indexer->query('SELECT * FROM nonexistent_table');
$indexer->run(); // throws PDOException: table not found
```

--------------------------------

### Catch IndexNotFoundException

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/errors.md

Example of how to handle the IndexNotFoundException using a try-catch block.

```php
use TeamTNT\TNTSearch\Exceptions\IndexNotFoundException;

try {
    $tnt->selectIndex('articles.index');
} catch (IndexNotFoundException $e) {
    echo "Index not found: " . $e->getMessage();
    // Handle: create the index or check storage path
}
```

--------------------------------

### Install TNTSearch via Composer

Source: https://github.com/teamtnt/tntsearch/blob/master/README.md

Use this command to add the TNTSearch library to your PHP project.

```bash
composer require teamtnt/tntsearch
```

--------------------------------

### Extending AbstractTokenizer

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Tokenizers.md

Example implementation of a custom tokenizer by extending the base class and implementing the TokenizerInterface.

```php
class MyTokenizer extends AbstractTokenizer implements TokenizerInterface
{
    static protected $pattern = '/\s+/';  // split on whitespace

    public function tokenize($text, $stopwords = []): array
    {
        // implementation
    }
}
```

--------------------------------

### Implement a custom CommaTokenizer

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Tokenizers.md

Creates a new tokenizer by implementing TokenizerInterface and provides usage example.

```php
use TeamTNT
Thearch
Tokenizer
TokenizerInterface;

class CommaTokenizer implements TokenizerInterface
{
    public function tokenize($text, $stopwords = []): array
    {
        if (!is_scalar($text)) {
            return [];
        }

        $text = mb_strtolower((string)$text);
        $tokens = explode(',', $text);
        $tokens = array_map('trim', $tokens);
        return array_diff($tokens, $stopwords);
    }

    public function getPattern(): string
    {
        return '/,/';
    }
}

// Usage:
$indexer->setTokenizer(new CommaTokenizer());
$indexer->query('SELECT id, tags FROM articles');
$indexer->run();
```

--------------------------------

### Execute boolean search queries

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Examples of using boolean operators like NOT and OR in search queries.

```php
$results = $tnt->searchBoolean('romeo -juliet', 50);
// Finds documents with "romeo" but NOT "juliet"

$results = $tnt->searchBoolean('(romeo juliet) or (hamlet prince)', 50);
```

--------------------------------

### Triggering Generic Exceptions

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/errors.md

Examples of configuration or logic errors that result in a generic Exception or LogicException.

```php
$tnt->loadConfig([
    'storage' => '/root/indices/',  // not writable by web server
]);
$indexer = $tnt->createIndex('articles.index'); // throws Exception

// Or:
class BadTokenizer extends AbstractTokenizer {} // no $pattern defined
$indexer->setTokenizer(new BadTokenizer());
$indexer->run(); // throws LogicException
```

--------------------------------

### Train TNTClassifier with examples

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTClassifier.md

Provide training text and category labels to build the classifier's internal word frequency counts.

```php
$classifier = new TNTClassifier();

// Learn positive examples
$classifier->learn('A great game', 'Sports');
$classifier->learn('What a game!', 'Sports');
$classifier->learn('Beautiful football match', 'Sports');

// Learn negative examples
$classifier->learn('The election was over', 'Not sports');
$classifier->learn('Political news update', 'Not sports');
$classifier->learn('Stock market rises', 'Not sports');
```

--------------------------------

### Configure TNTSearch with Managed MySQL

Source: https://github.com/teamtnt/tntsearch/blob/master/README.md

Example configuration for connecting to a managed MySQL provider requiring TLS via PDO options.

```php
// Connecting to a managed MySQL provider that requires TLS:
$tnt->loadConfig([
    'driver'   => 'mysql',
    'host'     => 'aws.connect.psdb.cloud',
    'database' => 'mydb',
    'username' => 'user',
    'password' => 'pass',
    'storage'  => __DIR__ . '/storage/',
    'options'  => [
        PDO::MYSQL_ATTR_SSL_CA => '/etc/ssl/cert.pem',
    ],
]);
```

--------------------------------

### Create and Populate Index

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Initialize a new index file and run a query to populate it.

```php
$indexer = $tnt->createIndex('articles.index');
$indexer->query('SELECT id, title, content FROM articles');
$indexer->run();
```

--------------------------------

### Create an Index File

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTIndexer.md

Initializes an empty index file and required tables.

```php
public function createIndex(string $indexName): TNTIndexer
```

```php
$indexer = new TNTIndexer($engine);
$indexer->createIndex('articles.index');
```

--------------------------------

### Create and Index Data

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/INDEX.md

Initialize the configuration and run the indexer on a database query.

```php
$tnt->loadConfig(['driver' => 'sqlite', ...]);
$indexer = $tnt->createIndex('articles.index');
$indexer->query('SELECT id, title, content FROM articles');
$indexer->run();
```

--------------------------------

### Run Index Creation Benchmark

Source: https://github.com/teamtnt/tntsearch/blob/master/benchmark/README.md

Generate a dataset and execute the index creation timing script.

```bash
# 1. Generate a deterministic dataset (default: 20,000 documents)
php benchmark/generate.php 20000

# 2. Time index creation over it
php benchmark/bench.php
```

--------------------------------

### Initialize and execute a search with TNTSearch

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/INDEX.md

Demonstrates the basic workflow of configuring the engine, creating an index from a database query, and performing a search.

```php
use TeamTNT\TNTSearch\TNTSearch;
use TeamTNT\TNTSearch\Stemmer\PorterStemmer;

// 1. Initialize
$tnt = new TNTSearch();
$tnt->loadConfig([
    'driver'   => 'sqlite',
    'database' => 'app.sqlite',
    'storage'  => __DIR__ . '/storage/',
    'stemmer'  => PorterStemmer::class,
]);

// 2. Create and populate index
$indexer = $tnt->createIndex('articles.index');
$indexer->query('SELECT id, title, content FROM articles');
$indexer->run();

// 3. Search
$tnt->selectIndex('articles.index');
$results = $tnt->search('php programming', 20);
// ['ids' => [7, 3, 10], 'hits' => 42, 'docScores' => [...], 'execution_time' => '3.1 ms']

// 4. Fetch results from your database
$ids = $results['ids'];  // Use these to fetch rows from your DB
```

--------------------------------

### loadConfig(array $config)

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Loads configuration settings and initializes the search engine. This method is required to set up the database driver, storage path, and other engine components.

```APIDOC
## loadConfig(array $config)

### Description
Loads configuration and initializes the search engine.

### Parameters
- **$config** (array) - Required - Configuration array with `driver`, `storage`, `stemmer` (optional), `tokenizer` (optional), `engine` (optional), etc.

### Throws
- `InvalidEngineException` if the engine is not a valid EngineInterface implementation.
```

--------------------------------

### Creating a Collection

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Utilities.md

Initialize a new collection with an array of items.

```php
$collection = new Collection([
    ['id' => 1, 'score' => 5.1],
    ['id' => 2, 'score' => 4.8],
    ['id' => 3, 'score' => 3.2],
]);
```

--------------------------------

### Load TNTSearch Configuration from Environment Variables

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/configuration.md

Demonstrates how to map environment variables into a configuration array for use with loadConfig().

```php
$config = [
    'driver'   => $_ENV['DB_DRIVER'] ?? 'sqlite',
    'database' => $_ENV['DB_PATH'] ?? __DIR__ . '/db.sqlite',
    'host'     => $_ENV['DB_HOST'] ?? 'localhost',
    'username' => $_ENV['DB_USER'] ?? 'root',
    'password' => $_ENV['DB_PASS'] ?? '',
    'storage'  => $_ENV['SEARCH_STORAGE'] ?? __DIR__ . '/storage/',
];

$tnt->loadConfig($config);
```

--------------------------------

### Get Total Documents

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Retrieves the total count of documents currently indexed.

```php
$count = $tnt->totalDocumentsInCollection();
echo "Index contains $count documents";
```

--------------------------------

### run()

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTIndexer.md

Executes the configured query and indexes all results.

```APIDOC
## run()

### Description
Executes the configured query and indexes all results. This method streams results and batches inserts into transactions for efficiency.
```

--------------------------------

### Perform Geographic Indexing and Search in PHP

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTGeoSearch.md

Demonstrates the complete lifecycle of creating a geographic index from a database and executing a proximity search.

```php
use TeamTNT\TNTSearch\TNTGeoSearch;
use TeamTNT\TNTSearch\Indexer\TNTGeoIndexer;

// 1. Create index (one-time)
$config = [
    'driver'   => 'sqlite',
    'database' => 'app.sqlite',
    'storage'  => __DIR__ . '/storage/',
];

$geo = new TNTGeoSearch();
$geo->loadConfig($config);

$indexer = new TNTGeoIndexer($geo->engine);
$indexer->createIndex('locations.index');
$indexer->query('SELECT id, longitude, latitude FROM restaurants');
$indexer->run();

// 2. Search (many times)
$geo->selectIndex('locations.index');

$userLocation = [
    'latitude'  => 51.5074,  // London
    'longitude' => -0.1278
];

$results = $geo->findNearest($userLocation, 10, 20); // 10 km, up to 20 results

foreach ($results['ids'] as $i => $restaurantId) {
    $km = $results['distances'][$i];
    echo "Restaurant $restaurantId: {$km} km away\n";
}

echo "Total nearby restaurants: " . $results['hits'];
```

--------------------------------

### Classify Text

Source: https://github.com/teamtnt/tntsearch/blob/master/README.md

Trains a classifier with labeled examples and predicts the category of new text.

```php
use TeamTNT\TNTSearch\Classifier\TNTClassifier;

$classifier = new TNTClassifier();
$classifier->learn('A great game', 'Sports');
$classifier->learn('The election was over', 'Not sports');

$guess = $classifier->predict('It was a close election');
echo $guess['label']; // "Not sports"

$classifier->save('sports.cls');
$classifier->load('sports.cls');
```

--------------------------------

### Run tests with Composer

Source: https://github.com/teamtnt/tntsearch/blob/master/CONTRIBUTING.md

Execute the project test suite using the Composer package manager.

```bash
$ composer test
```

--------------------------------

### Essential Configuration Keys

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/INDEX.md

Defines the required and optional configuration keys for initializing the search engine.

```php
[
    'driver'    => 'sqlite|mysql|pgsql|filesystem',  // required
    'database'  => 'path/to/db.sqlite',              // required
    'storage'   => 'path/to/indices/',               // required
    'stemmer'   => StemmerInterface::class,          // optional
    'tokenizer' => TokenizerInterface::class,        // optional
    'engine'    => EngineInterface::class,           // optional
]
```

--------------------------------

### Configure Fuzzy and Prefix Matching

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/INDEX.md

Enable fuzzy matching and prefix search-as-you-type functionality.

```php
$tnt->fuzziness(true);
$tnt->setFuzzyDistance(1);
$tnt->asYouType(true);
$results = $tnt->search('typ');  // matches typos and prefixes
```

--------------------------------

### Configure TNTSearch

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Load configuration settings including driver, database, and storage paths.

```php
$tnt->loadConfig([
    'driver'   => 'sqlite',
    'database' => __DIR__ . '/app.sqlite',
    'storage'  => __DIR__ . '/storage/',
    'stemmer'  => PorterStemmer::class,
]);
```

--------------------------------

### Configure Valid Engines

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/errors.md

Demonstrates the correct usage of valid search engine classes in the configuration.

```php
use TeamTNT\TNTSearch\Engines\SqliteEngine;   // default
use TeamTNT\TNTSearch\Engines\MysqlEngine;
use TeamTNT\TNTSearch\Engines\RedisEngine;

$tnt->loadConfig(['engine' => SqliteEngine::class]);  // OK
$tnt->loadConfig(['engine' => MysqlEngine::class]);   // OK
$tnt->loadConfig(['engine' => RedisEngine::class]);   // OK
```

--------------------------------

### Standard Search Pattern

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/errors.md

Follow the required sequence of loading configuration and selecting an index before executing a search.

```php
// Always follow this pattern:
$tnt->loadConfig($config);
$tnt->selectIndex('articles.index');  // must exist or throws IndexNotFoundException
$results = $tnt->search('query');
```

--------------------------------

### Handle Missing Index Files

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/errors.md

Verify the existence of an index file and create it if it is missing before performing a search.

```php
// Check if file exists:
$indexPath = $config['storage'] . 'articles.index';
if (!file_exists($indexPath)) {
    // Create it:
    $indexer = $tnt->createIndex('articles.index');
    $indexer->query('SELECT id, title FROM articles');
    $indexer->run();
}

// Then search:
$tnt->selectIndex('articles.index');
$results = $tnt->search('test');
```

--------------------------------

### EdgeNgramTokenizer::tokenize

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Tokenizers.md

Generates n-grams starting from the beginning of each word, useful for prefix matching and autocomplete.

```APIDOC
## EdgeNgramTokenizer::tokenize

### Description
Creates n-grams starting from the beginning of each word. This is particularly useful for autocomplete or search-as-you-type features.

### Method
public function tokenize($text, $stopwords = []): array

### Parameters
- **$text** (string) - Required - The input text to tokenize.
- **$stopwords** (array) - Optional - An array of words to exclude from the tokenization process.

### Example
```php
$tokenizer = new EdgeNgramTokenizer();
$tokens = $tokenizer->tokenize('hello');
// Returns: ['h', 'he', 'hel', 'hell', 'hello']
```
```

--------------------------------

### Select Index and Search

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Select an existing index file to perform search operations.

```php
$tnt->selectIndex('articles.index');
$results = $tnt->search('php');
```

--------------------------------

### Define EdgeNgramTokenizer class

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Tokenizers.md

Class definition for the EdgeNgramTokenizer which generates n-grams starting from the beginning of words.

```php
class EdgeNgramTokenizer extends AbstractTokenizer implements TokenizerInterface
{
    static protected $pattern = '/[^\p{L}\p{N}]+/u';

    public function tokenize($text, $stopwords = []): array
}
```

--------------------------------

### Retrieve and Update Index

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Get the indexer instance for the currently selected index to perform data modifications.

```php
$tnt->selectIndex('articles.index');
$index = $tnt->getIndex();
$index->insert(['id' => 11, 'title' => 'New', 'content' => 'Article']);
```

--------------------------------

### Retrieve Vocabulary Count

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTClassifier.md

Get the total number of unique words encountered during training, utilizing internal caching.

```php
public function vocabularyCount(): int
```

--------------------------------

### Configure SQLite Database

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/configuration.md

Basic configuration for using SQLite as the data source.

```php
$tnt->loadConfig([
    'driver'   => 'sqlite',
    'database' => __DIR__ . '/app.sqlite',  // path to SQLite file
    'storage'  => __DIR__ . '/storage/',    // index storage
]);
```

```php
$config = [
    'driver'   => 'sqlite',
    'database' => getcwd() . '/data.db',
    'storage'  => getcwd() . '/indices/',
    'stemmer'  => PorterStemmer::class,
];
$tnt->loadConfig($config);
```

--------------------------------

### Configure Filesystem Indexing

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/configuration.md

Configuration for indexing files directly from the local filesystem.

```php
$tnt->loadConfig([
    'driver'    => 'filesystem',
    'location'  => __DIR__ . '/docs/',
    'extension' => 'txt',
    'storage'   => __DIR__ . '/storage/',
]);
```

--------------------------------

### Handle Configuration Errors

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Catch exceptions when providing an invalid engine configuration.

```php
try {
    $tnt->loadConfig(['engine' => 'InvalidEngine']);
} catch (InvalidEngineException $e) {
    echo "Invalid engine configured";
}
```

--------------------------------

### createIndex(string $indexName)

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTIndexer.md

Creates an empty index file and initializes the necessary index tables.

```APIDOC
## createIndex(string $indexName)

### Description
Creates an empty index file and initializes index tables.

### Parameters
- **$indexName** (string) - Required - Name of the index file (e.g., `articles.index`)

### Returns
- **TNTIndexer** - Returns the instance for method chaining.
```

--------------------------------

### Initialize TNTSearch

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Instantiate the search engine class.

```php
$tnt = new TNTSearch();
```

--------------------------------

### Index data from the filesystem

Source: https://github.com/teamtnt/tntsearch/blob/master/README.md

Configure the indexer to read files from a specific directory and extension.

```php
$tnt->loadConfig([
    'driver'    => 'filesystem',
    'location'  => __DIR__ . '/docs/',
    'extension' => 'txt',
    'storage'   => __DIR__ . '/storage/',
]);
$indexer = $tnt->createIndex('docs.index');
$indexer->run();
```

--------------------------------

### Indexing from Database

Source: https://github.com/teamtnt/tntsearch/blob/master/README.md

Creates an index from a database query and runs the indexing process.

```APIDOC
## Indexer::run

### Description
Creates an index from a database query and processes it in batched transactions.

### Method
PHP Method

### Signature
$indexer = $tnt->createIndex('index_name');
$indexer->query('SELECT ...');
$indexer->run();
```

--------------------------------

### Perform a basic search with TNTSearch

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/README.md

Initializes the TNTSearch engine with a configuration array and executes a search query against a specified index.

```php
$tnt = new TNTSearch();
$tnt->loadConfig(['driver' => 'sqlite', 'database' => 'app.sqlite', 'storage' => '/storage/']);
$tnt->selectIndex('articles.index');
$results = $tnt->search('php', 20);
```

--------------------------------

### Enable Prefix Search

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/configuration.md

Enables as-you-type prefix matching for search queries.

```php
$tnt->selectIndex('articles.index');
$tnt->asYouType(true);

$results = $tnt->search('rom'); // matches "romeo", "romantic", etc.
```

--------------------------------

### Execute Bulk Indexing

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTIndexer.md

Runs the configured query and processes results in batches.

```php
public function run(): void
```

```php
$indexer->query('SELECT id, title, content FROM articles');
$indexer->run(); // bulk-indexes all rows
```

```php
try {
    $indexer->query('SELECT invalid_column FROM nonexistent_table');
    $indexer->run();
} catch (Exception $e) {
    echo "Query failed: " . $e->getMessage();
}
```

--------------------------------

### Implement safe search workflow in PHP

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/errors.md

Wraps search initialization, index selection, and query execution in try-catch blocks to handle specific TNTSearch exceptions.

```php
use TeamTNT\TNTSearch\TNTSearch;
use TeamTNT\TNTSearch\Exceptions\IndexNotFoundException;
use TeamTNT\TNTSearch\Exceptions\InvalidEngineException;

function safeSearch($config, $indexName, $query) {
    try {
        $tnt = new TNTSearch();
        $tnt->loadConfig($config);
    } catch (InvalidEngineException $e) {
        return ['error' => 'Invalid search engine configured', 'details' => $e->getMessage()];
    } catch (Exception $e) {
        return ['error' => 'Configuration error', 'details' => $e->getMessage()];
    }

    try {
        $tnt->selectIndex($indexName);
    } catch (IndexNotFoundException $e) {
        return ['error' => 'Index not found', 'details' => "Index '$indexName' does not exist"];
    } catch (Exception $e) {
        return ['error' => 'Index selection error', 'details' => $e->getMessage()];
    }

    try {
        $results = $tnt->search($query, 100);
        return ['success' => true, 'results' => $results];
    } catch (Exception $e) {
        return ['error' => 'Search failed', 'details' => $e->getMessage()];
    }
}

// Usage:
$result = safeSearch($config, 'articles.index', 'php programming');
if (isset($result['success'])) {
    echo "Found " . $result['results']['hits'] . " documents";
} else {
    echo "Error: " . $result['error'];
}
```

--------------------------------

### Configure PostgreSQL Database

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/configuration.md

Configuration for PostgreSQL database connections.

```php
$tnt->loadConfig([
    'driver'   => 'pgsql',
    'host'     => 'localhost',
    'database' => 'myapp',
    'username' => 'postgres',
    'password' => 'secret',
    'storage'  => __DIR__ . '/storage/',
]);
```

--------------------------------

### Set Custom Database Handle

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Configures a custom PDO instance for source data access before index creation.

```php
$pdo = new PDO('mysql:host=localhost;dbname=myapp', 'user', 'pass');
$tnt->setDatabaseHandle($pdo);
$indexer = $tnt->createIndex('articles.index');
```

--------------------------------

### Enable Full Stack Traces in PHP

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/errors.md

Use this configuration during development to display detailed error information and stack traces for debugging.

```php
// In development
ini_set('display_errors', 1);
error_reporting(E_ALL);

try {
    $tnt->selectIndex('articles.index');
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
    echo "File: " . $e->getFile() . " Line: " . $e->getLine() . "\n";
    echo $e->getTraceAsString();
}
```

--------------------------------

### Handle bulk index execution results

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTIndexer.md

Demonstrates the silent execution of the indexer and standard exception handling for errors.

```php
$indexer->run(); // no return value; index is written to disk
```

```php
try {
    $indexer->run();
} catch (Exception $e) {
    // Database error, permissions issue, etc.
}
```

--------------------------------

### Retrieve Fuzzy Search Settings

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Demonstrates checking the current fuzzy search status and distance configuration.

```php
if ($tnt->getFuzziness()) {
    echo "Fuzzy search enabled with distance " . $tnt->getFuzzyDistance();
}
```

--------------------------------

### loadConfig(array $config)

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTIndexer.md

Loads configuration settings for the indexer.

```APIDOC
## loadConfig(array $config)

### Description
Loads configuration for the indexer. Usually inherited from TNTSearch instance.

### Parameters
- **$config** (array) - Required - Configuration array
```

--------------------------------

### Stemming English words with PorterStemmer

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Stemmers.md

Demonstrates basic word stemming using the PorterStemmer class.

```php
$tests = [
    'running'     => 'run',
    'runs'        => 'run',
    'runner'      => 'runner',
    'computing'   => 'comput',
    'computer'    => 'comput',
    'agreement'   => 'agre',
    'agrees'      => 'agre',
];

foreach ($tests as $word => $expected) {
    $result = PorterStemmer::stem($word);
    echo "$word → $result\n";
}
```

--------------------------------

### Tokenizing Text with Default Tokenizer

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Tokenizers.md

Demonstrates splitting strings into tokens and applying stopword filtering.

```php
$tokenizer = new Tokenizer();
$tokens = $tokenizer->tokenize('Hello, World! test_case email@example.com');
// Returns: ['hello', 'world', 'test_case', 'email@example.com']

$tokens = $tokenizer->tokenize('Hello World', ['hello']);
// Returns: ['world']  // 'hello' filtered as stopword
```

--------------------------------

### Search with Results and Highlighting

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/INDEX.md

Executes a search query and retrieves corresponding database records with highlighted matches and snippets.

```php
$tnt->selectIndex('articles.index');

// Set options
$tnt->fuzziness(true);
$tnt->asYouType(true);

// Search
$results = $tnt->search('php programming', 20);

// Fetch and display
foreach ($results['ids'] as $docId) {
    $article = $db->query("SELECT * FROM articles WHERE id = ?", [$docId])->fetch();
    
    $title = $tnt->highlight($article['title'], 'php programming', 'mark');
    $snippet = $tnt->snippet('php programming', $article['content']);
    
    echo "<h3>$title</h3>";
    echo "<p>...$snippet...</p>
";
}

echo "Total results: " . $results['hits'];
```

--------------------------------

### Create and Query a Geographic Index

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTGeoSearch.md

Initializes the geo indexer and performs a proximity search for the nearest locations.

```php
use TeamTNT\TNTSearch\Indexer\TNTGeoIndexer;

$geo = new TNTGeoSearch();
$geo->loadConfig([
    'driver'   => 'sqlite',
    'database' => 'app.sqlite',
    'storage'  => __DIR__ . '/storage/',
]);

// Create geo index
$indexer = new TNTGeoIndexer($geo->engine);
$indexer->createIndex('shops.index');
$indexer->query('SELECT id, longitude, latitude FROM shops');
$indexer->run();

// Now search
$geo->selectIndex('shops.index');
$results = $geo->findNearest(
    ['latitude' => 48.137154, 'longitude' => 11.576124],
    2,
    10
);
```

--------------------------------

### Create a search index

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/README.md

Configures an indexer to pull data from a database query and run the indexing process with a specified language stemmer.

```php
$indexer = $tnt->createIndex('articles.index');
$indexer->query('SELECT id, title, content FROM articles');
$indexer->setLanguage('porter');
$indexer->run();
```

--------------------------------

### Wrap Indexing Operations in Try-Catch

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/configuration.md

Use this pattern to handle exceptions during index creation and execution, such as database connectivity or storage issues.

```php
try {
    $indexer = $tnt->createIndex('articles.index');
    $indexer->query('SELECT id, title FROM articles');
    $indexer->run();
} catch (Exception $e) {
    error_log("Indexing failed: " . $e->getMessage());
}
```

--------------------------------

### Define a ProductTokenizer class

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Tokenizers.md

Implements a custom tokenizer that splits text based on hyphens.

```php
class ProductTokenizer extends AbstractTokenizer implements TokenizerInterface
{
    static protected $pattern = '/-/';

    public function tokenize($text, $stopwords = []): array
}
```

--------------------------------

### Configure Redis Engine

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/configuration.md

Configures the engine to use Redis for storage, requiring host and port specifications.

```php
$tnt->loadConfig([
    'driver'      => 'sqlite',  // source database driver
    'database'    => 'app.sqlite',
    'storage'     => __DIR__ . '/storage/',
    'engine'      => RedisEngine::class,
    'redis_host'  => 'localhost',
    'redis_port'  => 6379,
]);
```

--------------------------------

### Configure SQL Server Database

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/configuration.md

Configuration for Microsoft SQL Server database connections.

```php
$tnt->loadConfig([
    'driver'   => 'sqlsrv',
    'host'     => 'server.database.windows.net',
    'database' => 'mydb',
    'username' => 'user@server',
    'password' => 'password',
    'storage'  => __DIR__ . '/storage/',
]);
```

--------------------------------

### Customize Classifier Instance

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTClassifier.md

Initialize a classifier with custom tokenizer and stemmer implementations before training.

```php
$classifier = new TNTClassifier();
$classifier->tokenizer = new BigramTokenizer();
$classifier->stemmer = new PorterStemmer();

$classifier->learn('Beautiful sunset', 'Nature');
```

--------------------------------

### Configure SQLite Write-Ahead Logging

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/configuration.md

Enable or disable WAL mode in the TNTSearch configuration. WAL is enabled by default to improve concurrency but should be disabled on network filesystems.

```php
$tnt->loadConfig([
    'driver'   => 'sqlite',
    'database' => 'app.sqlite',
    'storage'  => __DIR__ . '/storage/',
    'wal'      => true,  // default: true
]);
```

--------------------------------

### Fuzzy Configuration Getters

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Methods to retrieve current fuzzy search and as-you-type configuration settings.

```APIDOC
## Fuzzy Configuration Getters

### Methods
- `getFuzziness(): bool`
- `getFuzzyDistance(): int`
- `getFuzzyPrefixLength(): int`
- `getFuzzyMaxExpansions(): int`
- `getFuzzyNoLimit(): bool`
- `getAsYouType(): bool`
```

--------------------------------

### Indexer Configuration

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/configuration.md

Methods to configure the indexer before running the indexing process.

```APIDOC
## Indexer Configuration Methods

### disableOutput(bool $disable)
Suppresses progress output during bulk indexing.

### setStopWords(array $words)
Excludes specified words from the index. Must be called before run().

### decodeHtmlEntities(bool $decode)
Decodes HTML entities before indexing (default: false).
```

--------------------------------

### Search-as-you-type

Source: https://github.com/teamtnt/tntsearch/blob/master/README.md

Enables prefix matching for search-as-you-type functionality.

```APIDOC
## TNTSearch::asYouType

### Description
Enables prefix matching mode for the search engine.
```

--------------------------------

### createIndex(string $indexName, bool $disableOutput)

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Creates a new index file and returns a TNTIndexer instance used for populating the index with data.

```APIDOC
## createIndex(string $indexName, bool $disableOutput)

### Description
Creates a new index file and returns an indexer instance for populating it.

### Parameters
- **$indexName** (string) - Required - Name of the index file (e.g., `articles.index`)
- **$disableOutput** (bool) - Optional - If true, suppresses progress output during indexing (default: false)

### Returns
- `TNTIndexer` instance for building the index.
```

--------------------------------

### Implement a Custom Stemmer

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Stemmers.md

Create a custom stemmer by implementing the StemmerInterface and registering it with the indexer.

```php
use TeamTNT\TNTSearch\Stemmer\StemmerInterface;

class SimpleEnglishStemmer implements StemmerInterface
{
    public static function stem($word): string
    {
        // Simple suffix removal
        $suffixes = ['ing', 'ed', 'ly', 'er', 'est'];
        foreach ($suffixes as $suffix) {
            if (str_ends_with($word, $suffix)) {
                return substr($word, 0, -strlen($suffix));
            }
        }
        return $word;
    }
}

// Usage:
$indexer->setStemmer(new SimpleEnglishStemmer());
```

--------------------------------

### ProductTokenizer::tokenize

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Tokenizers.md

Splits text on hyphens, useful for product codes and hyphenated identifiers.

```APIDOC
## ProductTokenizer::tokenize

### Description
Splits the provided text into tokens based on hyphen delimiters.

### Signature
`public function tokenize($text, $stopwords = []): array`

### Parameters
- **text** (string) - The input string to tokenize.
- **stopwords** (array) - Optional list of words to exclude from the result.

### Example
```php
$tokenizer = new ProductTokenizer();
$tokens = $tokenizer->tokenize('PROD-2024-001-RED-SMALL');
// Returns: ['prod', '2024', '001', 'red', 'small']
```
```

--------------------------------

### Configure Primary Key for Indexing

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/errors.md

Ensure the primary key is the first column in the query or explicitly set via setPrimaryKey.

```php
// WRONG: id is not first
$indexer->query('SELECT title, id, content FROM articles');
$indexer->run(); // 'title' is treated as primary key!

// RIGHT: id is first
$indexer->query('SELECT id, title, content FROM articles');
$indexer->setPrimaryKey('id');  // optional, 'id' is default
$indexer->run();

// RIGHT: custom primary key
$indexer->query('SELECT article_id, title, content FROM articles');
$indexer->setPrimaryKey('article_id');
$indexer->run();
```

--------------------------------

### Implementing a Custom Tokenizer

Source: https://github.com/teamtnt/tntsearch/blob/master/README.md

Create a custom tokenizer by implementing TokenizerInterface or extending the default Tokenizer class.

```php
use TeamTNT\\
```

```php
use TeamTNT\TNTSearch\Tokenizer\Tokenizer;
use TeamTNT\TNTSearch\Tokenizer\TokenizerInterface;

class CommaTokenizer extends Tokenizer implements TokenizerInterface
{
    static protected $pattern = '/[\s,\.]+/';

    public function tokenize($text, $stopwords = [])
    {
        return preg_split($this->getPattern(), mb_strtolower($text), -1, PREG_SPLIT_NO_EMPTY);
    }
}

$indexer->setTokenizer(new CommaTokenizer);
// or: 'tokenizer' => CommaTokenizer::class in loadConfig()
```

--------------------------------

### Configure tokenizer at initialization

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/Tokenizers.md

Sets a specific tokenizer class within the TNTSearch configuration array.

```php
use TeamTNT
Thearch
Thearch;
use TeamTNT
Thearch
Tokenizer
BigramTokenizer;

$tnt = new TNTSearch();
$tnt->loadConfig([
    'driver'    => 'sqlite',
    'database'  => 'app.sqlite',
    'storage'   => __DIR__ . '/storage/',
    'tokenizer' => BigramTokenizer::class,
]);

$indexer = $tnt->createIndex('articles.index');
// BigramTokenizer is now baked into this index
```

--------------------------------

### Configure MySQL/MariaDB Database

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/configuration.md

Configuration for MySQL connections, including optional TLS settings for cloud databases.

```php
$tnt->loadConfig([
    'driver'   => 'mysql',
    'host'     => 'localhost',
    'database' => 'myapp',
    'username' => 'user',
    'password' => 'secret',
    'storage'  => __DIR__ . '/storage/',
]);
```

```php
$tnt->loadConfig([
    'driver'   => 'mysql',
    'host'     => 'aws.connect.psdb.cloud',
    'database' => 'production',
    'username' => 'user@branch',
    'password' => 'password',
    'storage'  => __DIR__ . '/storage/',
    'options'  => [
        PDO::MYSQL_ATTR_SSL_CA => '/etc/ssl/cert.pem',
    ],
]);
```

--------------------------------

### Configure Search Engine Driver

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/configuration.md

Sets the database driver and engine class for the search index.

```php
$tnt->loadConfig([
    'driver'  => 'mysql',
    'database' => 'mydb',
    'host'     => 'localhost',
    'username' => 'user',
    'password' => 'pass',
    'storage'  => __DIR__ . '/storage/',
    'engine'   => MysqlEngine::class,  // or SqliteEngine, RedisEngine
]);
```

--------------------------------

### Index data from a database

Source: https://github.com/teamtnt/tntsearch/blob/master/README.md

Use the indexer to stream database queries into an index. The first column of the query result is treated as the primary key.

```php
$indexer = $tnt->createIndex('articles.index');
$indexer->query('SELECT id, title, article FROM articles;'); // 1st column = primary key
// $indexer->setPrimaryKey('article_id'); // if the PK column isn't named "id"
// $indexer->includePrimaryKey();          // make the PK itself searchable (off by default)
// $indexer->setLanguage('german');        // pick a stemmer by language
$indexer->run();
```

--------------------------------

### Configure TNTSearch with MySQL and German Stemming

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/configuration.md

Initializes TNTSearch with custom engine, stemmer, and tokenizer settings, followed by index creation and search tuning.

```php
use TeamTNT\TNTSearch\TNTSearch;
use TeamTNT\TNTSearch\Stemmer\GermanStemmer;
use TeamTNT\TNTSearch\Tokenizer\BigramTokenizer;
use TeamTNT\TNTSearch\Engines\MysqlEngine;

$tnt = new TNTSearch();

// Configure for MySQL with German stemming
$tnt->loadConfig([
    'driver'    => 'mysql',
    'host'      => 'db.example.com',
    'database'  => 'content',
    'username'  => 'search_user',
    'password'  => 'secure_password',
    'storage'   => '/var/search_indices/',
    'engine'    => MysqlEngine::class,
    'stemmer'   => GermanStemmer::class,
    'tokenizer' => BigramTokenizer::class,
    'options'   => [
        PDO::MYSQL_ATTR_SSL_CA => '/etc/ssl/certs/ca.pem',
    ],
]);

// Index with custom settings
$indexer = $tnt->createIndex('articles.de.index');
$indexer->setLanguage('german');
$indexer->setStopWords(['der', 'die', 'das', 'und', 'oder']);
$indexer->includePrimaryKey();
$indexer->query('SELECT id, title, content FROM articles WHERE language = "de"');
$indexer->run();

// Search with tuning
$tnt->selectIndex('articles.de.index');
$tnt->fuzziness(true);
$tnt->setFuzzyDistance(1);
$tnt->asYouType(true);

$results = $tnt->search('münchen', 20);
```

--------------------------------

### Index Articles from Database

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/INDEX.md

Configures and runs an indexer to process database records into a searchable index.

```php
$config = [
    'driver'   => 'mysql',
    'host'     => 'localhost',
    'database' => 'myapp',
    'username' => 'user',
    'password' => 'pass',
    'storage'  => __DIR__ . '/indices/',
    'stemmer'  => PorterStemmer::class,
];

$tnt = new TNTSearch();
$tnt->loadConfig($config);

$indexer = $tnt->createIndex('articles.index');
$indexer->setLanguage('porter');
$indexer->setStopWords(['the', 'a', 'an', 'and', 'or']);
$indexer->query('SELECT id, title, content FROM articles WHERE published = 1');
$indexer->run();

echo "Indexed " . $indexer->totalDocumentsInCollection() . " documents";
```

--------------------------------

### Configure Tokenization

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/configuration.md

Sets the tokenizer class for the index, which determines how text is split into tokens.

```php
$tnt->loadConfig([
    'driver'    => 'sqlite',
    'database'  => 'app.sqlite',
    'storage'   => __DIR__ . '/storage/',
    // Uses default Tokenizer (Unicode word splitting)
]);
```

```php
$tnt->loadConfig([
    'driver'     => 'sqlite',
    'database'   => 'app.sqlite',
    'storage'    => __DIR__ . '/storage/',
    'tokenizer'  => BigramTokenizer::class,
]);

$indexer = $tnt->createIndex('articles.index');
$indexer->query('SELECT id, title FROM articles');
$indexer->run();
```

--------------------------------

### Perform dynamic document updates

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTIndexer.md

Full workflow for selecting an index and performing insert, update, and delete operations on documents.

```php
$tnt->selectIndex('articles.index');
$indexer = $tnt->getIndex();

// Add new document
$indexer->insert([
    'id'      => 12,
    'title'   => 'New Article',
    'content' => 'Fresh content'
]);

// Update existing
$indexer->update(11, [
    'id'      => 11,
    'title'   => 'Changed Title',
    'content' => 'Changed content'
]);

// Delete old
$indexer->delete(10);

// Verify
echo $indexer->totalDocumentsInCollection(); // updated count
```

--------------------------------

### asYouType(bool $value)

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Enables prefix matching for search-as-you-type functionality.

```APIDOC
## asYouType(bool $value)

### Description
Enables prefix matching for search-as-you-type functionality.

### Parameters
- **$value** (bool) - Required - true = enable prefix matching

### Example
$tnt->asYouType(true);
$results = $tnt->search('jul'); // matches "juliet", "julius"
```

--------------------------------

### Enable as-you-type search in TNTSearch

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTSearch.md

Enables prefix matching to support search-as-you-type functionality.

```php
public function asYouType(bool $value): void
```

```php
$tnt->asYouType(true);
$results = $tnt->search('jul'); // matches "juliet", "julius"
```

--------------------------------

### Set Primary Key in PHP

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTIndexer.md

Define the primary key column before running the indexer. Must match the first column of the SQL query.

```php
$indexer->query('SELECT article_id, title, content FROM articles');
$indexer->setPrimaryKey('article_id');
$indexer->run();
```

--------------------------------

### Initialize TNTClassifier

Source: https://github.com/teamtnt/tntsearch/blob/master/_autodocs/api-reference/TNTClassifier.md

Instantiate the classifier with default tokenizer and stemmer settings.

```php
$classifier = new TNTClassifier();
```
Tokens:
Raw