async _rename(oldPath, newPath) {
    const params = {
      ...this._createParams(newPath),
      CopySource: `/${this._bucket}/${this._dir}${oldPath}`,
    }
    await this._s3.copyObject(params)
    await this._s3.deleteObject(this._createParams(oldPath))
  }

ini_set('memory_limit', '10G');

async _rename(oldPath, newPath) {
    const size = this._getSize(oldPath)
    const params = { ...this._createParams(newPath), CopySource: `/${this._bucket}/${this._dir}${oldPath}` }
    const multipartParams = await this._s3.createMultipartUpload(params)
    try {
      const parts = []
      let start = 0
      while (start < size) {
        const range = `${start}-${Math.min(start + MAX_PART_SIZE, size) - 1}`
        const partParams = { ...params, PartNumber: parts.length + 1, CopySourceRange: range }
        const upload = await this._s3.uploadPartCopy(partParams)
        parts.push({ ETag: upload.CopyPartResult.ETag, PartNumber: partParams.PartNumber })
        start += MAX_PART_SIZE
      }
      await this._s3.completeMultipartUpload({ ...multipartParams, MultipartUpload: { Parts: parts } })
    } catch (e) {
      await this._s3.abortMultipartUpload(multipartParams)
      throw e
    }
    await this._s3.deleteObject(this._createParams(oldPath))
  }

async _write(file, buffer, position) {
    if (typeof file !== 'string') {
      file = file.fd
    }
    const uploadParams = this._createParams(file)
    const fileSize = +(await this._s3.headObject(uploadParams)).ContentLength
    if (fileSize < MIN_PART_SIZE) {
      const resultBuffer = Buffer.alloc(Math.max(fileSize, position + buffer.length))
      const fileContent = (await this._s3.getObject(uploadParams)).Body
      fileContent.copy(resultBuffer)
      buffer.copy(resultBuffer, position)
      await this._s3.putObject({ ...uploadParams, Body: resultBuffer })
      return { buffer, bytesWritten: buffer.length }
    } else {
      // using this trick: https://stackoverflow.com/a/38089437/72637
      // multipart fragments have a minimum size of 5Mo and a max of 5Go unless they are last
      // splitting the file in 3 parts: [prefix, edit, suffix]
      // if `prefix` is bigger than 5Mo, it will be sourced from uploadPartCopy()
      // otherwise otherwise it will be downloaded, concatenated to `edit`
      // `edit` will always be an upload part
      // `suffix` will always be sourced from uploadPartCopy()
      // Then everything will be sliced in 5Gb parts before getting uploaded
      const multipartParams = await this._s3.createMultipartUpload(uploadParams)
      const copyMultipartParams = {
        ...multipartParams,
        CopySource: `/${this._bucket}/${this._dir + file}`,
      }
      try {
        const parts = []
        const prefixSize = position
        let suffixOffset = prefixSize + buffer.length
        let suffixSize = Math.max(0, fileSize - suffixOffset)
        let hasSuffix = suffixSize > 0
        let editBuffer = buffer
        let editBufferOffset = position
        let partNumber = 1
        let prefixPosition = 0
        // use floor() so that last fragment is handled in the if bellow
        let fragmentsCount = Math.floor(prefixSize / MAX_PART_SIZE)
        const prefixFragmentSize = MAX_PART_SIZE
        let prefixLastFragmentSize = prefixSize - prefixFragmentSize * fragmentsCount
        if (prefixLastFragmentSize >= MIN_PART_SIZE) {
          // the last fragment of the prefix is smaller than MAX_PART_SIZE, but bigger than the minimum
          // so we can copy it too
          fragmentsCount++
          prefixLastFragmentSize = 0
        }
        for (let i = 0; i < fragmentsCount; i++) {
          const fragmentEnd = Math.min(prefixPosition + prefixFragmentSize, prefixSize)
          assert.strictEqual(fragmentEnd - prefixPosition <= MAX_PART_SIZE, true)
          const range = `bytes=${prefixPosition}-${fragmentEnd - 1}`
          const copyPrefixParams = { ...copyMultipartParams, PartNumber: partNumber++, CopySourceRange: range }
          const part = await this._s3.uploadPartCopy(copyPrefixParams)
          parts.push({ ETag: part.CopyPartResult.ETag, PartNumber: copyPrefixParams.PartNumber })
          prefixPosition += prefixFragmentSize
        }
        if (prefixLastFragmentSize) {
          // grab everything from the prefix that was too small to be copied, download and merge to the edit buffer.
          const downloadParams = { ...uploadParams, Range: `bytes=${prefixPosition}-${prefixSize - 1}` }
          const prefixBuffer = prefixSize > 0 ? (await this._s3.getObject(downloadParams)).Body : Buffer.alloc(0)
          editBuffer = Buffer.concat([prefixBuffer, buffer])
          editBufferOffset -= prefixLastFragmentSize
        }
        if (hasSuffix && editBuffer.length < MIN_PART_SIZE) {
          // the edit fragment is too short and is not the last fragment
          // let's steal from the suffix fragment to reach the minimum size
          // the suffix might be too short and itself entirely absorbed in the edit fragment, making it the last one.
          const complementSize = Math.min(MIN_PART_SIZE - editBuffer.length, suffixSize)
          const complementOffset = editBufferOffset + editBuffer.length
          suffixOffset += complementSize
          suffixSize -= complementSize
          hasSuffix = suffixSize > 0
          const prefixRange = `bytes=${complementOffset}-${complementOffset + complementSize - 1}`
          const downloadParams = { ...uploadParams, Range: prefixRange }
          const complementBuffer = (await this._s3.getObject(downloadParams)).Body
          editBuffer = Buffer.concat([editBuffer, complementBuffer])
        }
        const editParams = { ...multipartParams, Body: editBuffer, PartNumber: partNumber++ }
        const editPart = await this._s3.uploadPart(editParams)
        parts.push({ ETag: editPart.ETag, PartNumber: editParams.PartNumber })
        if (hasSuffix) {
          // use ceil because the last fragment can be arbitrarily small.
          const suffixFragments = Math.ceil(suffixSize / MAX_PART_SIZE)
          let suffixFragmentOffset = suffixOffset
          for (let i = 0; i < suffixFragments; i++) {
            const fragmentEnd = suffixFragmentOffset + MAX_PART_SIZE
            assert.strictEqual(Math.min(fileSize, fragmentEnd) - suffixFragmentOffset <= MAX_PART_SIZE, true)
            const suffixRange = `bytes=${suffixFragmentOffset}-${Math.min(fileSize, fragmentEnd) - 1}`
            const copySuffixParams = { ...copyMultipartParams, PartNumber: partNumber++, CopySourceRange: suffixRange }
            const suffixPart = (await this._s3.uploadPartCopy(copySuffixParams)).CopyPartResult
            parts.push({ ETag: suffixPart.ETag, PartNumber: copySuffixParams.PartNumber })
            suffixFragmentOffset = fragmentEnd
          }
        }
        await this._s3.completeMultipartUpload({
          ...multipartParams,
          MultipartUpload: { Parts: parts },
        })
      } catch (e) {
        await this._s3.abortMultipartUpload(multipartParams)
        throw e
      }
    }
  }

1. Warning Error: PDOStatement::execute(): SQLSTATE[42P08]: Ambiguous parameter: 7 ERROR:  inconsistent types deduced for parameter $1
2. LINE 4:                 $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11...
3.                         ^
4. DETAIL:  text versus character varying in [/var/www/html/app/Controller/Component/ImportExportComponent.php, line 279]

switch($paramTypes[$key]) {
                        case 'boolean':
                            $preparedQuery->bindParam(":$key", $value,PDO::PARAM_BOOL );
                            break;
                        case 'bigint':
                        case 'integer':
                        case 'smallint':
                        case 'serial':
                        case 'smallserial':
                        case 'bigserial':
                            $preparedQuery->bindParam(":$key", $value,PDO::PARAM_INT );
                        break;
                        case 'character varying':
                        case 'character':
                            $preparedQuery->bindParam(":$key", $value,PDO::PARAM_STR );
                            break ;
                        case 'text':
                            $preparedQuery->bindParam(":$key", $value,PDO::PARAM_LOB );
                            break ;
                        default:
                            if($tableName !== 'passenger_file_numbers') {
                                echo " FILETYPE $key ".$paramTypes[$key]."\n";
                            }
                            $preparedQuery->bindParam(":$key", $value );
                    }