Drops a routine if it exists.

@param string $routineType The type of the routine (function of procedure).
@param string $routineName The name of the routine.
504233
public static function dropRoutine(string $routineType, string $routineName): void
  {
    $query = sprintf('drop %s if exists `%s`', $routineType, $routineName);

    self::executeNone($query);
  }
783214
public function deleteConfigTypeCMDL($configTypeName)
    {
        $this->repositoryInfo = [];

        $this->getCMDLCache()->flushAll();

        try {
            $url = 'config/' . $configTypeName;

            $this->getClient()->setDefaultOption('query',
                [
                    'userinfo' => [
                        'username'  => $this->userInfo->getUsername(),
                        'firstname' => $this->userInfo->getFirstname(),
                        'lastname'  => $this->userInfo->getLastname()
                    ]
                ]);

            $this->getClient()->delete($url);

            $configTypeNames = $this->getConfiguration()->getConfigTypeNames();

            if (($key = array_search($configTypeName, $configTypeNames)) !== false) {
                unset($configTypeNames[$key]);
            }

            $this->getConfiguration()->addConfigTypes($configTypeNames);

            $this->getCMDLCache()->flushAll();

            return true;
        } catch (ClientException $e) {

            return false;
        }
    }
843077
private function resetCraftMatrixServiceBlockTypesCache()
    {
        $obj = Craft::$app->matrix;
        $refObject = new \ReflectionObject($obj);
        if ($refObject->hasProperty('_fetchedAllBlockTypesForFieldId')) {
            $refProperty1 = $refObject->getProperty('_fetchedAllBlockTypesForFieldId');
            $refProperty1->setAccessible(true);
            $refProperty1->setValue($obj, false);
        }
    }
312197
public static function callProcedure(string $procedureName): void
  {
    $query = 'call '.$procedureName.'()';

    self::$dl->executeNone($query);
  }
855922
public function removeParametersFromColumnName($columnName = null)
    {
        if (null !== $columnName) {
            $newParams = [];
            $parameters = $this->getParameters();
            foreach ($parameters as $key => $parameter) {
                if ($parameter['column'] != $columnName) {
                    $newParams[$key] = $parameter;
                }
            }

            $this->setParameters($newParams);
        }
    }
937874
public function removeProcessByName($name)
    {
        foreach ($this->processes as $key => $process) {
            if ($process->name() == $name) {
                if ($process->isRunning()) {
                    throw new \RuntimeException("can not remove a running process");
                }
                unset($this->processes[$key]);
            }
        }
    }
1335372
public function dropSchema($schemaName)
    {
        $sql = sprintf("DROP SCHEMA IF EXISTS %s CASCADE;", $this->quoteSchemaName($schemaName));
        $this->execute($sql);
    }
379315
static void drop(CallInfo callInfo, DB db, String tableName) {
    String sql = String.format("DROP TABLE %s", tableName);
    db.access(callInfo, () -> {
      db.logSetup(callInfo, sql);
      try (WrappedStatement ws = db.compile(sql)) {
        PreparedStatement dropStmt = ws.getStatement();
        dropStmt.execute();
      }
      return 0; 
    });
  }
442609
public static function deleteColumn(string $tableName, string $column)
    {
        if(Schema::hasTable($tableName)) {
            Schema::table(
                $tableName, function ($table) use ($tableName, $column) {
                    if(Schema::hasColumn($tableName, $column)) {
                        $table->dropColumn($column);
                    }
                }
            );
        }
    }
746068
public void overwriteDeclaredType(StaticScope scope, String name, JSType type) {
    checkState(isDeclaredForScope(scope, name), "missing name %s", name);
    reregister(scope, type, name);
  }
48912
public void setNull(String parameterName, int sqlType) {
        recordByName(parameterName, getDeclaredMethod(CallableStatement.class, "setNull", String.class, int.class), parameterName, sqlType);
    }
38218
public function remove($name = null)
    {
        $list = self::$_postTypes;
        
        unset($list[$name]);
        
        if (!$name) {
            $list = null;
        }
        
        self::$_postTypes = $list;
    }
867570
private function dropRoutine(): void
  {
    if (isset($this->rdbmsOldRoutineMetadata))
    {
      MetaDataLayer::dropRoutine($this->rdbmsOldRoutineMetadata['routine_type'], $this->routineName);
    }
  }
1108028
public static void drop(DB db, String tableName) {
    DBSetup.drop(CallInfo.create(), db, tableName);
  }
860704
@Override
    public void delete(final String varName) {
        runWithContext(new RhinoCallable<Void, RuntimeException>() {
            @Override
            protected Void doCall(Context cx, Scriptable scope) {
                scope.delete(varName);
                return null;
            }
        });
    }
495654
private function generateSP(string $tableName, string $spType, string $spName): string
  {
    switch ($spType)
    {
      case 'UPDATE':
        $routine = new UpdateRoutine($this->input,
                                     $this->output,
                                     $this->helper,
                                     $spType,
                                     $spName,
                                     $tableName,
                                     $this->dataSchema);
        break;

      case 'DELETE':
        $routine = new DeleteRoutine($this->input,
                                     $this->output,
                                     $this->helper,
                                     $spType, $spName,
                                     $tableName,
                                     $this->dataSchema);
        break;

      case 'SELECT':
        $routine = new SelectRoutine($this->input,
                                     $this->output,
                                     $this->helper,
                                     $spType, $spName,
                                     $tableName,
                                     $this->dataSchema);
        break;

      case 'INSERT':
        $routine = new InsertRoutine($this->input,
                                     $this->output,
                                     $this->helper,
                                     $spType,
                                     $spName,
                                     $tableName,
                                     $this->dataSchema);
        break;

      default:
        throw new FallenException("Unknown type '%s'", $spType);
    }

    return $routine->getCode();
  }
518296
private function _processTypeValue($pType, $pValue, &$pPrepared)
    {
        if (is_array($pValue)) {
            foreach($pValue as $subValue) {
                $pPrepared[] = (string)$subValue;
            }
        } else if ($pValue !== NULL) {
            $pPrepared[] = $pValue;
        }
    }