CollectionHandler.php

<?php

/**
 * ArangoDB PHP client: collection handler
 *
 * @package   ArangoDBClient
 * @author    Jan Steemann
 * @copyright Copyright 2012, triagens GmbH, Cologne, Germany
 */

namespace ArangoDBClient;

/**
 * Provides management of collections
 *
 * The collection handler fetches collection data from the server and
 * creates collections on the server.
 *
 * @package   ArangoDBClient
 * @since     0.2
 */
class CollectionHandler extends Handler
{

    /**
     * documents array index
     */
    const ENTRY_DOCUMENTS = 'documents';

    /**
     * collection parameter
     */
    const OPTION_COLLECTION = 'collection';

    /**
     * example parameter
     */
    const OPTION_EXAMPLE = 'example';

    /**
     * example parameter
     */
    const OPTION_NEW_VALUE = 'newValue';

    /**
     * example parameter
     */
    const OPTION_CREATE_COLLECTION = 'createCollection';

    /**
     * attribute parameter
     */
    const OPTION_ATTRIBUTE = 'attribute';

    /**
     * keys parameter
     */
    const OPTION_KEYS = 'keys';

    /**
     * stream parameter
     */
    const OPTION_STREAM = 'stream';

    /**
     * left parameter
     */
    const OPTION_LEFT = 'left';

    /**
     * right parameter
     */
    const OPTION_RIGHT = 'right';

    /**
     * closed parameter
     */
    const OPTION_CLOSED = 'closed';

    /**
     * latitude parameter
     */
    const OPTION_LATITUDE = 'latitude';

    /**
     * longitude parameter
     */
    const OPTION_LONGITUDE = 'longitude';

    /**
     * distance parameter
     */
    const OPTION_DISTANCE = 'distance';

    /**
     * radius parameter
     */
    const OPTION_RADIUS = 'radius';

    /**
     * skip parameter
     */
    const OPTION_SKIP = 'skip';

    /**
     * index parameter
     */
    const OPTION_INDEX = 'index';

    /**
     * limit parameter
     */
    const OPTION_LIMIT = 'limit';

    /**
     * fields
     */
    const OPTION_FIELDS = 'fields';
    
    /**
     * fieldValueTypes (zkd index only)
     */
    const OPTION_FIELD_VALUE_TYPES = 'fieldValueTypes';

    /**
     * unique
     */
    const OPTION_UNIQUE = 'unique';

    /**
     * type
     */
    const OPTION_TYPE = 'type';

    /**
     * size option
     */
    const OPTION_SIZE = 'size';

    /**
     * geo index option
     */
    const OPTION_GEO_INDEX = 'geo';

    /**
     * geoJson option
     */
    const OPTION_GEOJSON = 'geoJson';

    /**
     * hash index option
     */
    const OPTION_HASH_INDEX = 'hash';

    /**
     * fulltext index option
     */
    const OPTION_FULLTEXT_INDEX = 'fulltext';

    /**
     * minLength option
     */
    const OPTION_MIN_LENGTH = 'minLength';
    
    /**
     * zkd index option
     */
    const OPTION_ZKD_INDEX = 'zkd';

    /**
     * skiplist index option
     */
    const OPTION_SKIPLIST_INDEX = 'skiplist';

    /**
     * persistent index option
     */
    const OPTION_PERSISTENT_INDEX = 'persistent';
    
    /**
     * ttl index option
     */
    const OPTION_TTL_INDEX = 'ttl';
    
    /**
     * expireAfter option
     */
    const OPTION_EXPIRE_AFTER = 'expireAfter';
    
    /**
     * inBackground option
     */
    const OPTION_IN_BACKGROUND = 'inBackground';

    /**
     * sparse index option
     */
    const OPTION_SPARSE = 'sparse';

    /**
     * count option
     */
    const OPTION_COUNT = 'count';

    /**
     * query option
     */
    const OPTION_QUERY = 'query';

    /**
     * checksum option
     */
    const OPTION_CHECKSUM = 'checksum';

    /**
     * revision option
     */
    const OPTION_REVISION = 'revision';
    
    /**
     * responsible shard option
     */
    const OPTION_RESPONSIBLE_SHARD = 'responsibleShard';
    
    /**
     * shards option
     */
    const OPTION_SHARDS = 'shards';

    /**
     * properties option
     */
    const OPTION_PROPERTIES = 'properties';

    /**
     * figures option
     */
    const OPTION_FIGURES = 'figures';

    /**
     * load option (deprecated)
     */
    const OPTION_LOAD = 'load';

    /**
     * Creates a new collection on the server
     *
     * This will add the collection on the server and return its id
     * The id is mainly returned for backwards compatibility, but you should use the collection name for any reference to the collection.   *
     * This will throw if the collection cannot be created
     *
     * @throws Exception
     *
     * @param mixed $collection - collection object to be created on the server or a string with the name
     * @param array $options    - an array of options.
     *                          <p>Options are:<br>
     *                          <li>'type'                 - 2 -> normal collection, 3 -> edge-collection</li>
     *                          <li>'waitForSync'          - if set to true, then all removal operations will instantly be synchronised to disk / If this is not specified, then the collection's default sync behavior will be applied.</li>
     *                          <li>'isSystem'             - false->user collection(default), true->system collection .</li>
     *                          <li>'keyOptions'           - key options to use.</li>
     *                          <li>'distributeShardsLike' - name of prototype collection for identical sharding.</li>
     *                          <li>'numberOfShards'       - number of shards for the collection.</li>
     *                          <li>'replicationFactor'    - number of replicas to keep (default: 1).</li>
     *                          <li>'writeConcern'         - minimum number of replicas to be successful when writing (default: 1).</li>
     *                          <li>'shardKeys'            - array of shard key attributes.</li>
     *                          <li>'shardingStrategy'     - sharding strategy to use in cluster.</li>
     *                          <li>'smartJoinAttribute'   - attribute name for smart joins (if not shard key).</li>
     *                          <li>'schema'               - collection schema.</li>
     *                          </p>
     *
     * @return mixed - id of collection created
     */
    public function create($collection, array $options = [])
    {
        if (is_string($collection)) {
            $name       = $collection;
            $collection = new Collection();
            $collection->setName($name);
            foreach ($options as $key => $value) {
                $collection->{'set' . ucfirst($key)}($value);
            }
        }
        if ($collection->getWaitForSync() === null) {
            $collection->setWaitForSync($this->getConnectionOption(ConnectionOptions::OPTION_WAIT_SYNC));
        }

        if ($collection->getIsSystem() === null) {
            $collection->setIsSystem($this->getConnectionOption(ConnectionOptions::OPTION_IS_SYSTEM));
        }

        $type   = $collection->getType() ?: Collection::getDefaultType();
        $params = [
            Collection::ENTRY_NAME         => $collection->getName(),
            Collection::ENTRY_TYPE         => $type,
            Collection::ENTRY_WAIT_SYNC    => $collection->getWaitForSync(),
            Collection::ENTRY_IS_SYSTEM    => $collection->getIsSystem(),
            Collection::ENTRY_KEY_OPTIONS  => $collection->getKeyOptions(),
            Collection::ENTRY_SCHEMA       => $collection->getSchema(),
        ];

        // set extra cluster attributes
        if ($collection->getDistributeShardsLike() !== null) {
            $params[Collection::ENTRY_DISTRIBUTE_SHARDS_LIKE] = $collection->getDistributeShardsLike();
        }

        if ($collection->getNumberOfShards() !== null) {
            $params[Collection::ENTRY_NUMBER_OF_SHARDS] = $collection->getNumberOfShards();
        }
        
        if ($collection->getReplicationFactor() !== null) {
            $params[Collection::ENTRY_REPLICATION_FACTOR] = $collection->getReplicationFactor();
        }
        
        if ($collection->getWriteConcern() !== null) {
            $params[Collection::ENTRY_WRITE_CONCERN] = $collection->getWriteConcern();
        }
        
        if ($collection->getShardingStrategy() !== null) {
            $params[Collection::ENTRY_SHARDING_STRATEGY] = $collection->getShardingStrategy();
        }

        if (is_array($collection->getShardKeys())) {
            $params[Collection::ENTRY_SHARD_KEYS] = $collection->getShardKeys();
        }
        
        if ($collection->getSmartJoinAttribute() !== null) {
            $params[Collection::ENTRY_SMART_JOIN_ATTRIBUTE] = $collection->getSmartJoinAttribute();
        }


        $response = $this->getConnection()->post(Urls::URL_COLLECTION, $this->json_encode_wrapper($params));

        //    $location = $response->getLocationHeader();
        //    if (!$location) {
        //      throw new ClientException('Did not find location header in server response');
        //    }
        $jsonResponse = $response->getJson();
        $id           = $jsonResponse['id'];
        $collection->setId($id);

        return $id;
    }

    /**
     * unload option (deprecated)
     */
    const OPTION_UNLOAD = 'unload';

    /**
     * truncate option
     */
    const OPTION_TRUNCATE = 'truncate';

    /**
     * rename option
     */
    const OPTION_RENAME = 'rename';


    /**
     * exclude system collections
     */
    const OPTION_EXCLUDE_SYSTEM = 'excludeSystem';


    /**
     * Check if a collection exists
     *
     * This will call self::get() internally and checks if there
     * was an exception thrown which represents an 404 request.
     *
     * @throws Exception When any other error than a 404 occurs
     *
     * @param  mixed $collection - collection id as a string or number
     *
     * @return boolean
     */
    public function has($collection)
    {
        $collection = $this->makeCollection($collection);

        // get current exception logging status, and then turn it off
        // temporarily
        $old = Exception::getLogging();
        Exception::setLogging(false);

        try {
            // will throw ServerException if entry could not be retrieved
            $this->get($collection);
            
            // restore previous Exception logging status
            Exception::setLogging($old);

            return true;
        } catch (ServerException $e) {
            // restore previous Exception logging status
            Exception::setLogging($old);

            // we are expecting a 404 to return boolean false
            if ($e->getCode() === 404) {
                return false;
            }

            // just rethrow
            throw $e;
        }
    }


    /**
     * Get the number of documents in a collection
     *
     * This will throw if the collection cannot be fetched from the server
     *
     * @throws Exception
     *
     * @param mixed $collection - collection id as a string or number
     * @param bool  $details    - optional, will provide per-shard counts in a cluster
     *
     * @return mixed - int if details=false, the number of documents in the collection, array if details=true
     */
    public function count($collection, $details = false)
    {
        $headers    = [];
        $this->addTransactionHeader($headers, $collection);

        $collection = $this->makeCollection($collection);
        $url        = UrlHelper::buildUrl(Urls::URL_COLLECTION, [$collection, self::OPTION_COUNT]);
        $url        = UrlHelper::appendParamsUrl($url, ['details' => $details]);
        $response   = $this->getConnection()->get($url, $headers);
        $data       = $response->getJson();
        return $data[self::OPTION_COUNT];
    }


    /**
     * Get information about a collection
     *
     * This will throw if the collection cannot be fetched from the server
     *
     * @throws Exception
     *
     * @param mixed $collection - collection id as a string or number
     *
     * @return Collection - the collection fetched from the server
     */
    public function get($collection)
    {
        $collection = $this->makeCollection($collection);

        $url      = UrlHelper::buildUrl(Urls::URL_COLLECTION, [$collection]);
        $response = $this->getConnection()->get($url);

        $data = $response->getJson();

        return Collection::createFromArray($data);
    }


    /**
     * Get properties of a collection
     *
     * This will throw if the collection cannot be fetched from the server
     *
     * @throws Exception
     *
     * @param mixed $collection - collection id as a string or number
     *
     * @return Collection - the collection fetched from the server
     */
    public function getProperties($collection)
    {
        $collection = $this->makeCollection($collection);
        $url        = UrlHelper::buildUrl(Urls::URL_COLLECTION, [$collection, self::OPTION_PROPERTIES]);
        $response   = $this->getConnection()->get($url);

        $data = $response->getJson();

        return Collection::createFromArray($data);
    }


    /**
     * Get figures for a collection
     *
     * This will throw if the collection cannot be fetched from the server
     *
     * @throws Exception
     *
     * @param mixed $collection - collection id as a string or number
     *
     * @return array - the figures for the collection
     */
    public function figures($collection)
    {
        $collection = $this->makeCollection($collection);
        $url        = UrlHelper::buildUrl(Urls::URL_COLLECTION, [$collection, self::OPTION_FIGURES]);
        $response   = $this->getConnection()->get($url);

        $data = $response->getJson();

        return $data[self::OPTION_FIGURES];
    }


    /**
     * Calculate a checksum of the collection.
     *
     * Will calculate a checksum of the meta-data (keys and optionally revision ids)
     * and optionally the document data in the collection.
     *
     * @throws Exception
     *
     * @param mixed   $collection           - collection as string or object
     * @param boolean $withRevisions        - optional boolean whether or not to include document revision ids
     *                                      in the checksum calculation.
     * @param boolean $withData             - optional boolean whether or not to include document body data in the
     *                                      checksum calculation.
     *
     * @return array - array containing keys "checksum" and "revision"
     */
    public function getChecksum($collection, $withRevisions = false, $withData = false)
    {
        $url      = UrlHelper::buildUrl(Urls::URL_COLLECTION, [$this->makeCollection($collection), self::OPTION_CHECKSUM]);
        $url      = UrlHelper::appendParamsUrl($url, ['withRevisions' => $withRevisions, 'withData' => $withData]);
        $response = $this->getConnection()->get($url);

        return $response->getJson();
    }

    /**
     * Returns the Collections revision ID
     *
     * The revision id is a server-generated string that clients can use to check whether data in a collection has
     * changed since the last revision check.
     *
     * @throws Exception
     *
     * @param mixed $collection - collection as string or object
     *
     * @return array - containing a key revision
     */
    public function getRevision($collection)
    {
        $url      = UrlHelper::buildUrl(Urls::URL_COLLECTION, [$this->makeCollection($collection), self::OPTION_REVISION]);
        $response = $this->getConnection()->get($url);

        return $response->getJson();
    }

    /**
     * Rename a collection
     *
     * @throws Exception
     *
     * @param mixed  $collection - collection as string or object
     * @param string $name       - new name for collection
     *
     * @return bool - always true, will throw if there is an error
     */
    public function rename($collection, $name)
    {
        $params = [Collection::ENTRY_NAME => $name];
        $this->getConnection()->put(
            UrlHelper::buildUrl(Urls::URL_COLLECTION, [$this->makeCollection($collection), self::OPTION_RENAME]),
            $this->json_encode_wrapper($params)
        );

        return true;
    }

    /**
     * Load a collection into the server's memory
     *
     * This will load the given collection into the server's memory.
     *
     * @throws Exception
     *
     * @param mixed $collection - collection as string or object
     *
     * @deprecated not necessary anymore
     *
     * @return HttpResponse - HTTP response object
     */
    public function load($collection)
    {
        $result = $this->getConnection()->put(
            UrlHelper::buildUrl(Urls::URL_COLLECTION, [$this->makeCollection($collection), self::OPTION_LOAD]),
            ''
        );

        return $result;
    }

    /**
     * Unload a collection from the server's memory
     *
     * This will unload the given collection from the server's memory.
     *
     * @throws Exception
     *
     * @param mixed $collection - collection as string or object
     *
     * @deprecated not necessary anymore
     *
     * @return HttpResponse - HTTP response object
     */
    public function unload($collection)
    {
        $result = $this->getConnection()->put(
            UrlHelper::buildUrl(Urls::URL_COLLECTION, [$this->makeCollection($collection), self::OPTION_UNLOAD]),
            ''
        );

        return $result;
    }


    /**
     * Truncate a collection
     *
     * This will remove all documents from the collection but will leave the metadata and indexes intact.
     *
     * @throws Exception
     *
     * @param mixed $collection - collection id as string or number or collection object
     *
     * @return bool - always true, will throw if there is an error
     */
    public function truncate($collection)
    {
        $headers      = [];
        $bodyParams   = [];
        $this->addTransactionHeader($headers, $collection);
        if ($collection instanceof StreamingTransactionCollection) {
            $bodyParams['transactionId'] = $collection->getTrxId();
        }

        $collection   = $this->makeCollection($collection);

        $this->getConnection()->put(
            UrlHelper::buildUrl(Urls::URL_COLLECTION, [$collection, self::OPTION_TRUNCATE]),
            $this->json_encode_wrapper($bodyParams),
            $headers
        );

        return true;
    }


    /**
     * Drop a collection
     *
     * @throws Exception
     *
     * @param mixed $collection - collection id as string or number or collection object
     * @param array $options    - an array of options for the drop operation
     *
     * @return bool - always true, will throw if there is an error
     */
    public function drop($collection, array $options = [])
    {
        $appendix = '';
        if (is_array($options) && isset($options['isSystem'])) {
            $appendix = '?isSystem=' . UrlHelper::getBoolString($options['isSystem']);
        }

        $this->getConnection()->delete(UrlHelper::buildUrl(Urls::URL_COLLECTION, [$this->makeCollection($collection)]) . $appendix);

        return true;
    }


    /**
     * Checks if the collectionId given, is valid. Returns true if it is, or false if it is not.
     *
     * @param $collectionId
     *
     * @return bool
     */
    public function isValidCollectionId($collectionId)
    {
        return !$collectionId || !(is_string($collectionId) || is_float($collectionId) || is_int($collectionId));
    }

    /**
     * Get list of all available collections per default with the collection names as index.
     * Returns empty array if none are available.
     *
     * @param array $options            - optional - an array of options.
     *                                  <p>Options are :<br>
     *                                  <li>'excludeSystem' -   With a value of true, all system collections will be excluded from the response.</li>
     *                                  <li>'keys' -  With a value of "collections", the index of the resulting array is numerical,
     *                                  With a value of "names", the index of the resulting array are the collection names.</li>
     *                                  </p>
     *
     * @return array
     * @throws \ArangoDBClient\Exception
     * @throws \ArangoDBClient\ClientException
     */
    public function getAllCollections(array $options = [])
    {
        $options = array_merge(['excludeSystem' => false, 'keys' => 'result'], $options);
        $params  = [];
        if ($options['excludeSystem'] === true) {
            $params[self::OPTION_EXCLUDE_SYSTEM] = true;
        }
        $url      = UrlHelper::appendParamsUrl(Urls::URL_COLLECTION, $params);
        $response = $this->getConnection()->get(UrlHelper::buildUrl($url, []));
        $response = $response->getJson();
        if (isset($response[$options['keys']])) {
            $result = [];
            foreach ($response[$options['keys']] as $collection) {
                $result[$collection['name']] = $collection;
            }

            return $result;
        }

        return $response;
    }


    /**
     * Gets the collectionId from the given collectionObject or string/integer
     *
     * @param mixed $collection
     *
     * @return mixed
     */
    public function getCollectionId($collection)
    {
        if ($collection instanceof Collection) {
            $collectionId = $collection->getId();

            return $collectionId;
        }

        $collectionId = $collection;

        return $collectionId;
    }


    /**
     * Gets the collectionId from the given collectionObject or string/integer
     *
     * @param mixed $collection
     *
     * @return mixed
     */
    public function getCollectionName($collection)
    {
        if ($collection instanceof Collection) {
            $collectionId = $collection->getName();

            return $collectionId;
        }

        $collectionId = $collection;

        return $collectionId;
    }


    /**
     * Import documents from a file
     *
     * This will throw on all errors except insertion errors
     *
     * @throws Exception
     *
     * @param mixed $collectionId   - collection as string or object
     * @param mixed $importFileName - The filename that holds the import data.
     * @param array $options        - optional - an array of options.
     *                              <p>Options are :<br>
     *                              'type' -  if type is not set or it's set to '' or null, the Header-Value format must be provided in the import file.<br>
     *                              <p>
     *                              <li>                       if set to 'documents', then the file's content must have its documents line by line. Each line will be interpreted as a document.</li>
     *                              <li>                       if set to 'array' then the file's content must provide the documents as a list of documents instead of the above line by line.</li>
     *                              <br>
     *                              More info on how the import functionality works: <a href ="https://github.com/triAGENS/ArangoDB/wiki/HttpImport">https://github.com/triAGENS/ArangoDB/wiki/HttpImport</a>
     *                              </p>
     *                              <br>
     *                              </li>
     *                              <li>'createCollection' - If true, create the collection if it does not exist. Defaults to false </li>
     *                              </p>
     *
     * @return array - returns an array with the server's response data from the import command
     */
    public function importFromFile($collection, $importFileName, array $options = [])
    {

        $contents = file_get_contents($importFileName);
        if ($contents === false) {
            throw new ClientException('Input file "' . $importFileName . '" could not be found.');
        }

        return $this->import($collection, $contents, $options);
    }


    /**
     * Import documents into a collection
     *
     * This will throw on all errors except insertion errors
     *
     *
     * @param              $collection   mixed $collection - collection as string or object
     * @param string|array $importData   - The data to import. This can be a string holding the data according to the type of import, or an array of documents
     * @param array        $options      - optional - an array of options.
     *                                   <p>Options are :<br>
     *                                   <li>
     *                                   'type' -  if type is not set or it's set to '' or null, the Header-Value format must be provided in the import file.<br>
     *                                   <p>
     *                                   <li>                       if set to 'documents', then the file's content must have its documents line by line. Each line will be interpreted as a document.</li>
     *                                   <li>                       if set to 'array' then the file's content must provide the documents as a list of documents instead of the above line by line.</li>
     *                                   <br>
     *                                   More info on how the import functionality works: <a href ="https://github.com/triAGENS/ArangoDB/wiki/HttpImport">https://github.com/triAGENS/ArangoDB/wiki/HttpImport</a>
     *                                   </p>
     *                                   <br>
     *
     *                                   </li>
     *                                   <li>'createCollection' - If true, create the collection if it does not exist. Defaults to false </li>
     *                                   </p>
     *
     *                                   Other options as described in API Documentation*
     *
     * @see https://www.arangodb.com/docs/stable/http/bulk-imports.html
     *
     * @return array
     * @throws \ArangoDBClient\Exception
     * @throws \ArangoDBClient\ClientException
     */
    public function import($collection, $importData, array $options = [])
    {
        $collection = $this->makeCollection($collection);

        $tmpContent = '';
        if (is_array($importData)) {
            foreach ($importData as $document) {
                /** @var $document Document */
                $tmpContent .= $document->toJson() . "\r\n";
            }
            $importData = $tmpContent;
            unset($tmpContent);
            $options['type'] = 'documents';
        }

        if ((isset($options['createCollection']) && $options['createCollection']) ||
            $this->getConnection()->getOption(ConnectionOptions::OPTION_CREATE)) {
            $this->lazyCreateCollection($collection, $options);
        }

        $params = array_merge(
            [self::OPTION_COLLECTION => $collection],
            $options
        );

        if (array_key_exists('type', $options)) {
            switch ($options['type']) {
                case 'documents':
                    $params[self::OPTION_TYPE] = 'documents';
                    break;
                case 'array':
                    $params[self::OPTION_TYPE] = 'array';
                    break;
            }
        }

        $url = UrlHelper::appendParamsUrl(Urls::URL_IMPORT, $params);

        $response = $this->getConnection()->post($url, $importData);

        return $response->getJson();
    }


    /**
     * Create a hash index
     *
     * @param mixed   $collection   - the collection as name or object
     * @param array   $fields       - an array of fields
     * @param bool    $unique       - whether the values in the index should be unique or not
     * @param bool    $sparse       - whether the index should be sparse
     * @param bool    $inBackground - true if index shall be created in background
     *
     * @deprecated use CollectionHandler::createIndex instead
     *
     * @return array - server response of the created index
     * @throws \ArangoDBClient\Exception
     */
    public function createHashIndex($collection, array $fields, $unique = null, $sparse = null, $inBackground = false)
    {
        $indexOptions = [
            self::OPTION_TYPE   => 'hash',
            self::OPTION_FIELDS => $fields
        ];

        if ($unique) {
            $indexOptions[self::OPTION_UNIQUE] = (bool) $unique;
        }
        if ($sparse) {
            $indexOptions[self::OPTION_SPARSE] = (bool) $sparse;
        }
        if ($inBackground) {
            $indexOptions[self::OPTION_IN_BACKGROUND] = (bool) $inBackground;
        }

        return $this->createIndex($collection, $indexOptions);
    }

    /**
     * Create a fulltext index
     *
     * @param mixed  $collection   - collection as string or object
     * @param array  $fields       - an array of fields
     * @param int    $minLength    - the minimum length of words to index
     * @param bool   $inBackground - true if index shall be created in background
     *
     * @deprecated use CollectionHandler::createIndex instead
     *
     * @return array - server response of the created index
     * @throws \ArangoDBClient\Exception
     */
    public function createFulltextIndex($collection, array $fields, $minLength = null, $inBackground = false)
    {
        $indexOptions = [
            self::OPTION_TYPE   => 'fulltext',
            self::OPTION_FIELDS => $fields
        ];

        if ($minLength) {
            $indexOptions[self::OPTION_MIN_LENGTH] = $minLength;
        }
        if ($inBackground) {
            $indexOptions[self::OPTION_IN_BACKGROUND] = (bool) $inBackground;
        }

        return $this->createIndex($collection, $indexOptions);
    }
    
    
    /**
     * Create a zkd index
     *
     * @param mixed  $collection      - collection as string or object
     * @param array  $fields          - an array of fields
     * @param bool   $unique          - whether the index is unique or not
     * @param string $fieldValueTypes - data type of index values
     * @param bool   $inBackground    - true if index shall be created in background
     *
     * @deprecated use CollectionHandler::createIndex instead
     *
     * @return array - server response of the created index
     * @throws \ArangoDBClient\Exception
     */
    public function createZkdIndex($collection, array $fields, $unique = null, $fieldValueTypes = "double", $inBackground = false)
    {
        $indexOptions = [
            self::OPTION_TYPE   => 'zkd',
            self::OPTION_FIELDS => $fields,
            self::OPTION_FIELD_VALUE_TYPES => $fieldValueTypes,
        ];

        if ($unique) {
            $indexOptions[self::OPTION_UNIQUE] = (bool) $unique;
        }
        if ($inBackground) {
            $indexOptions[self::OPTION_IN_BACKGROUND] = (bool) $inBackground;
        }

        return $this->createIndex($collection, $indexOptions);
    }

    /**
     * Create a skip-list index
     *
     * @param mixed  $collection   - collection as string or object
     * @param array  $fields       - an array of fields
     * @param bool   $unique       - whether the index is unique or not
     * @param bool   $sparse       - whether the index should be sparse
     * @param bool   $inBackground - true if index shall be created in background
     *
     * @deprecated use CollectionHandler::createIndex instead
     *
     * @return array - server response of the created index
     * @throws \ArangoDBClient\Exception
     */
    public function createSkipListIndex($collection, array $fields, $unique = null, $sparse = null, $inBackground = false)
    {
        $indexOptions = [
            self::OPTION_TYPE   => 'skiplist',
            self::OPTION_FIELDS => $fields
        ];

        if ($unique) {
            $indexOptions[self::OPTION_UNIQUE] = (bool) $unique;
        }
        if ($sparse) {