PHPackages                             railken/search-query - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [API Development](/categories/api)
4. /
5. railken/search-query

ActiveLibrary[API Development](/categories/api)

railken/search-query
====================

v3.0.1(2y ago)339.8k13MITPHPPHP >=7.1

Since Oct 15Pushed 2y ago2 watchersCompare

[ Source](https://github.com/railken/search-query)[ Packagist](https://packagist.org/packages/railken/search-query)[ RSS](/packages/railken-search-query/feed)WikiDiscussions master Synced 2w ago

READMEChangelogDependencies (3)Versions (29)Used By (3)

Search Query
============

[](#search-query)

[![Actions Status](https://github.com/railken/search-query/workflows/Test/badge.svg)](https://github.com/railken/search-query/actions)

Converts a simple expression (e.g. 'x eq 1 or y gt 2') into a tree object. This can be pretty usefull when building the API endpoint for a search.

Requirements
------------

[](#requirements)

PHP 7.1 or later.

Composer
--------

[](#composer)

You can install it via [Composer](https://getcomposer.org/) by typing the following command:

```
composer require railken/search-query
```

Demo
----

[](#demo)

[![demo](https://raw.githubusercontent.com/railken/search-query/master/demo/demo.gif)](https://raw.githubusercontent.com/railken/search-query/master/demo/demo.gif)

Usage
-----

[](#usage)

A simple usage looks like this:

```
   use Railken\SQ\QueryParser;
   use Railken\SQ\Resolvers as Resolvers;

   $parser = new QueryParser();
   $parser->addResolvers([
      new Resolvers\ValueResolver(),
      new Resolvers\KeyResolver(),
      new Resolvers\GroupingResolver(),
      new Resolvers\NotEqResolver(),
      new Resolvers\EqResolver(),
      new Resolvers\LteResolver(),
      new Resolvers\LtResolver(),
      new Resolvers\GteResolver(),
      new Resolvers\GtResolver(),
      new Resolvers\CtResolver(),
      new Resolvers\SwResolver(),
      new Resolvers\NotInResolver(),
      new Resolvers\InResolver(),
      new Resolvers\EwResolver(),
      new Resolvers\NotNullResolver(),
      new Resolvers\NullResolver(),
      new Resolvers\AndResolver(),
      new Resolvers\OrResolver(),
      new Resolvers\TextResolver(),
   ]);
   $result = $query->parse('x eq 1 or y > 1');
```

The result formatted in json of `$result`:

```
{
  "type": "Railken\\SQ\\Nodes\\OrNode",
  "value": "OR",
  "childs": [
    {
      "type": "Railken\\SQ\\Nodes\\EqNode",
      "value": "EQ",
      "childs": [
        {
          "type": "Railken\\SQ\\Nodes\\KeyNode",
          "value": "x"
        },
        {
          "type": "Railken\\SQ\\Nodes\\ValueNode",
          "value": "1"
        }
      ]
    },
    {
      "type": "Railken\\SQ\\Nodes\\GtNode",
      "value": "GT",
      "childs": [
        {
          "type": "Railken\\SQ\\Nodes\\KeyNode",
          "value": "y"
        },
        {
          "type": "Railken\\SQ\\Nodes\\ValueNode",
          "value": "1"
        }
      ]
    }
  ]
}
```

Nodes
-----

[](#nodes)

### Key node

[](#key-node)

All alphanumeric (starting with alphabetic character) are converted as `KeyNode`. Other characters allowed: `_`

Examples:

```
created_at

```

### Value node

[](#value-node)

All numbers and strings are converted as `ValueNode`. The delimiter of strings can be either `'` or `"`

Examples:

```
"An apple"
30.20

```

### Group node

[](#group-node)

All round parenthesis create a group node `( ... )`. Of course a nested group can be made. If a parenthesis is missing an exception will be thrown

Examples:

```
(x or y) and z
((x > 10 and w) or (y > 5 and f)) and z

```

### AND, OR

[](#and-or)

This operators requires a `Node` before and after, otherwise an exception will be thrown.

Can be expressed as literals (and, or) or as symbols (&&, ||)

**Important**: If a parent group is defined and the LogicNode is the only child, the LogicNode will take the place of the GroupNode.

Examples:

```
x or y || z
x and y && z

```

### EQ, NOT\_EQ, GT, GTE, LT, LTE

[](#eq-not_eq-gt-gte-lt-lte)

All these operators requires `KeyNode` or a `ValueNode` before and afters. Can be expressed as literals (eq, not eq, gt, gte, lt, lte) or as symbols (=, !=, >, >=, < <=)

Examples:

```
x eq 1
x = 1
x gt 1
x > 1
x gte 1
x >= 1
x lt 1
x < 1
x lte 1
x