DROP [PUBLIC] SYNONYM [ schema. ] synonym [FORCE] ;
497866
public Sql[] generateSql(DropSynonymStatement statement, Database database, SqlGeneratorChain chain) {
		StringBuilder sql = new StringBuilder("DROP ");

		if (statement.isPublic() != null && statement.isPublic()) {
			sql.append("PUBLIC ");
		}

		sql.append("SYNONYM ");

		if (statement.getSynonymSchemaName() != null) {
			sql.append(statement.getSynonymSchemaName()).append(".");
		}

		sql.append(statement.getSynonymName());

		if (statement.isForce() != null && statement.isForce()) {
			sql.append(" FORCE");
		}

		return new Sql[] { new UnparsedSql(sql.toString()) };
	}
490536
@Override
    public void dropSchema()
    {
        try
        {
            if (operation != null && ("create-drop").equalsIgnoreCase(operation))
            {
                r.dbDrop(databaseName);
            }
        }
        catch (Exception e)
        {
            logger.error("Error while dropping schema", e);
            throw new SchemaGenerationException(e, "RethinkDB");
        }
    }
955695
def drop_schema(client, table_name):
        
        query = 'DROP TABLE {cf}'
        return client.execute(query.format(cf=table_name),
                              {}, ConsistencyLevel.QUORUM)
922326
public function down()
    {
    	Schema::drop('SL_Databases');
		Schema::drop('SL_Tables');
		Schema::drop('SL_Fields');
		Schema::drop('SL_Definitions');
		Schema::drop('SL_BusRules');
		Schema::drop('SL_Tree');
		Schema::drop('SL_Node');
		Schema::drop('SL_NodeResponses');
		Schema::drop('SL_Conditions');
		Schema::drop('SL_ConditionsVals');
		Schema::drop('SL_ConditionsNodes');
		Schema::drop('SL_ConditionsArticles');
		Schema::drop('SL_DataLoop');
		Schema::drop('SL_DataSubsets');
		Schema::drop('SL_DataHelpers');
		Schema::drop('SL_DataLinks');
		Schema::drop('SL_Images');
		Schema::drop('SL_SearchRecDump');
		Schema::drop('SL_DesignTweaks');
		Schema::drop('SL_Sess');
		Schema::drop('SL_SessLoops');
		Schema::drop('SL_NodeSavesPage');
		Schema::drop('SL_NodeSaves');
		Schema::drop('SL_SessEmojis');
		Schema::drop('SL_SessSite');
		Schema::drop('SL_SessPage');
		Schema::drop('SL_Tokens');
		Schema::drop('SL_UsersRoles');
		Schema::drop('SL_Contact');
		Schema::drop('SL_Emails');
		Schema::drop('SL_Emailed');
		Schema::drop('SL_UsersActivity');
		Schema::drop('SL_LogActions');
		Schema::drop('SL_Zips');
		Schema::drop('SL_AddyGeo');
		Schema::drop('SL_Uploads');
	
    }
1333575
def drop_field(app_name, model_name, field_name):
    
    app_config = apps.get_app_config(app_name)
    model = app_config.get_model(model_name)
    field = model._meta.get_field(field_name)
    with connection.schema_editor() as schema_editor:
        schema_editor.remove_field(model, field)
316988
function clearDrops(sense) {
        sense.dropsStarted = [];
        sense.dropOver = null;
        sense.dropEvt = {
            dataType: 'text/plain',
            dataTransfer: ''
        };
    }
1246801
def drop kwargs={}
      force = kwargs.arg :force, false

      cmd = 'aptly snapshot drop'
      cmd += ' -force' if force
      cmd += " #{@name.quote}"

      Aptly::runcmd cmd
    end
685770
def synonyms(self):
        
        if self.cid:
            results = get_json(self.cid, operation='synonyms')
            return results['InformationList']['Information'][0]['Synonym'] if results else []
225483
function forcePublicMetadata(metadata) {
        delete metadata.isProtected;
        delete metadata.isPrivate;
        metadata.isPublic = metadata.forcedPublic = true;
    }
227517
def drop(self, auth, resource, defer=False):
        
        return self._call('drop', auth, [resource], defer)
933579
def run_drop(args):
    """"""
    dbname = bigchaindb.config['database']['name']

    if not args.yes:
        response = input_on_stderr('Do you want to drop `{}` database? [y/n]: '.format(dbname))
        if response != 'y':
            return

    conn = backend.connect()
    dbname = bigchaindb.config['database']['name']
    try:
        schema.drop_database(conn, dbname)
    except DatabaseDoesNotExist:
        print("Cannot drop '{name}'. The database does not exist.".format(name=dbname), file=sys.stderr)
997853
function(connection, collection, relations, cb) {
      log.debug('drop:', collection);
      // Add in logic here to delete a collection (e.g. DROP TABLE logic)

      return connections[connection].drop(collection, relations, cb);
    }
1123451
def drop_schema(self, schema, cascade=False):
        
        if schema in self.schemas:
            sql = "DROP SCHEMA " + schema
            if cascade:
                sql = sql + " CASCADE"
            self.execute(sql)
289136
def drop_database(self, name, force=False):
        
        if not force or self.exists_database(name):
            tables = self.list_tables(database=name)
            udfs = self.list_udfs(database=name)
            udas = self.list_udas(database=name)
        else:
            tables = []
            udfs = []
            udas = []
        if force:
            for table in tables:
                self.log('Dropping {0}'.format('{0}.{1}'.format(name, table)))
                self.drop_table_or_view(table, database=name)
            for func in udfs:
                self.log(
                    'Dropping function {0}({1})'.format(func.name, func.inputs)
                )
                self.drop_udf(
                    func.name,
                    input_types=func.inputs,
                    database=name,
                    force=True,
                )
            for func in udas:
                self.log(
                    'Dropping aggregate function {0}({1})'.format(
                        func.name, func.inputs
                    )
                )
                self.drop_uda(
                    func.name,
                    input_types=func.inputs,
                    database=name,
                    force=True,
                )
        else:
            if len(tables) > 0 or len(udfs) > 0 or len(udas) > 0:
                raise com.IntegrityError(
                    'Database {0} must be empty before '
                    'being dropped, or set '
                    'force=True'.format(name)
                )
        statement = ddl.DropDatabase(name, must_exist=not force)
        return self._execute(statement)
20997
void dropConstraint(Session session, HsqlName name, boolean cascade) {

        Table t = getTable(session, name.parent.name, name.parent.schema.name);
        TableWorks tw = new TableWorks(session, t);

        tw.dropConstraint(name.name, cascade);
    }
376785
def replace_all_synonyms(synonyms, request_options = {})
      forward_to_replicas = request_options[:forwardToReplicas] || request_options['forwardToReplicas'] || false
      batch_synonyms(synonyms, forward_to_replicas, true, request_options)
    end
577651
def dropdb(force=False):
    """"""

    if force:
        logger.info(
            "Terminating any other connections to %s on %s",
            repr(DB["NAME"]),
            repr(DB["HOST"]),
        )
        kill_other_psql_sessions()

    logger.info("Dropping database %s", repr(DB["NAME"]))
    return shell('dropdb -U "{USER}" -h "{HOST}" "{NAME}"'.format(**DB))