Google App Engine'deki tüm veri deposu nasıl silinir?

Google App Engine'deki tüm veri deposunun nasıl silineceğini bilen var mı ?

Bahsettiğin ise canlı veri deposuna , ardından uygulamanızdaki (AppEngine'de giriş) veri deposu için özetini açın - silmek istediğiniz tablo için tüm satırları seçin> dataviewer ve sil düğmesine basın (eğer gerekecek bunu tüm tablolarınız için yapın). Remote_api aracılığıyla programlı olarak aynısını yapabilirsiniz (ama ben hiç kullanmadım).

Bahsettiğin Eğer geliştirme veri deposuna :, sadece aşağıdaki dosyayı silmeniz gerektiği "./WEB-INF/appengine-generated/local_db.bin" . Geliştirme sunucusunu bir sonraki çalıştırmanızda dosya sizin için yeniden oluşturulacak ve net bir db'ye sahip olacaksınız.

Daha sonra projenizi temizlediğinizden emin olun.

Bu, Google Application Engine ile oynamaya başladığınızda işinize yarayacak küçük ipuçlarından biridir. Kendinizi veri deposunda kalıcı nesneler bulacaksınız, ardından kalıcı varlıklarınız için JDO nesne modelini değiştirerek, uygulamanızın her yerde çökmesine neden olacak eski verilerle sonuçlanacağını göreceksiniz.

En iyi yaklaşım, Nick'in önerdiği gibi uzak API yöntemidir, kendisi Google'dan bir App Engine mühendisi , bu yüzden ona güvenin.

Bunu yapmak o kadar da zor değil ve en son 1.2.5 SDK, remote_shell_api.py'yi raftan çıkarıyor. Yeni SDK'yı indirmeye gidin. Ardından aşağıdaki adımları izleyin:

• uzak sunucuyu komut satırınızda bağlayın: remote_shell_api.py yourapp /remote_api Kabuk, oturum açma bilgilerinizi soracak ve yetkilendirilmişse sizin için bir Python kabuğu oluşturacaktır. Uygulamanızda / remote_api için kurulum url işleyicisine ihtiyacınız var.yaml

• Silmek istediğiniz varlıkları getirin, kod şuna benzer:

    from models import Entry
    query = Entry.all(keys_only=True)
    entries =query.fetch(1000)
    db.delete(entries)
    \# This could bulk delete 1000 entities a time

2013-10-28 Güncellemesi :

• remote_shell_api.pyile değiştirilmiştir ve belgelere göre remote_api_shell.pybağlanmanız gerekir .remote_api_shell.py -s your_app_id.appspot.com

• Yeni bir deneysel özellik olan Datastore Admin , uygulama ayarlarında etkinleştirdikten sonra, web kullanıcı arayüzü aracılığıyla veri deponuzu toplu olarak silebilir ve yedekleyebilirsiniz.

Datastore'da toplu silme işleminin en hızlı ve verimli yolu , en son Google I / O'da duyurulan yeni eşleyici API'yi kullanmaktır .

Tercih ettiğiniz dil Python ise , eşleştiricinizi bir mapreduce.yaml dosyasına kaydetmeniz ve aşağıdaki gibi bir işlev tanımlamanız yeterlidir :

from mapreduce import operation as op
def process(entity):
 yield op.db.Delete(entity)

Açık Java size bir göz atmalısınız bu makalede böyle bir fonksiyon önermektedir:

@Override
public void map(Key key, Entity value, Context context) {
    log.info("Adding key to deletion pool: " + key);
    DatastoreMutationPool mutationPool = this.getAppEngineContext(context)
            .getMutationPool();
    mutationPool.delete(value.getKey());
}

DÜZENLEME:
SDK 1.3.8'den beri, bu amaç için bir Datastore yönetici özelliği var

Sen edebilirsiniz geliştirme sunucusu veri deposuna temizlemek sunucuyu çalıştırdığınızda:

/path/to/dev_appserver.py --clear_datastore=yes myapp

Ayrıca kısaltabilirsiniz --clear_datastoreile -c.

Önemli miktarda veriniz varsa, onu silmek için bir komut dosyası kullanmanız gerekir. Yine de, veri deposunu istemci tarafından basit bir şekilde temizlemek için remote_api'yi kullanabilirsiniz.

İşte gidiyorsunuz: Datastore Yöneticisine gidin ve ardından silmek istediğiniz Varlık türünü seçin ve Sil'e tıklayın. Mapreduce silme işini halleder!

Girişleri App Engine Datastore'dan kaldırmak için kullanabileceğiniz birkaç yol vardır:

1. Öncelikle, girdileri gerçekten silmeniz gerekip gerekmediğini düşünün. Bu pahalıdır ve bunları çıkarmamak daha ucuz olabilir.

2. Datastore Yöneticisini kullanarak tüm girişleri elle silebilirsiniz.

3. Remote API'yi kullanabilir ve girişleri etkileşimli olarak kaldırabilirsiniz.

4. Girişleri programlı olarak birkaç satır kod kullanarak kaldırabilirsiniz.

5. Görev Sıralarını ve İmleçleri kullanarak bunları toplu olarak kaldırabilirsiniz.

6. Veya daha sağlam ve daha süslü bir şey elde etmek için Mapreduce'u kullanabilirsiniz.

Bu yöntemlerin her biri aşağıdaki blog gönderisinde açıklanmıştır: http://www.shiftedup.com/2015/03/28/how-to-bulk-delete-entries-in-app-engine-datastore

Umarım yardımcı olur!

Bunu yapmanın sıfır kurulum yolu, çalışan uygulamanızın halihazırda otomatik olarak sahip olduğu yönetici hizmetine isteğe bağlı bir yürütme kodu HTTP isteği göndermektir:

import urllib
import urllib2

urllib2.urlopen('http://localhost:8080/_ah/admin/interactive/execute',
    data = urllib.urlencode({'code' : 'from google.appengine.ext import db\n' +
                                      'db.delete(db.Query())'}))

Kaynak

Bunu nereden aldım http://code.google.com/appengine/articles/remote_api.html .

Etkileşimli Konsolu Oluşturun

Öncelikle etkileşimli bir uygulama konsolu tanımlamanız gerekir. Öyleyse, appengine_console.py adlı bir dosya oluşturun ve şunu girin:

#!/usr/bin/python
import code
import getpass
import sys

# These are for my OSX installation. Change it to match your google_appengine paths. sys.path.append("/Applications/GoogleAppEngineLauncher.app/Contents/Resources/GoogleAppEngine-default.bundle/Contents/Resources/google_appengine")
sys.path.append("/Applications/GoogleAppEngineLauncher.app/Contents/Resources/GoogleAppEngine-default.bundle/Contents/Resources/google_appengine/lib/yaml/lib")

from google.appengine.ext.remote_api import remote_api_stub
from google.appengine.ext import db

def auth_func():
  return raw_input('Username:'), getpass.getpass('Password:')

if len(sys.argv) < 2:
  print "Usage: %s app_id [host]" % (sys.argv[0],)
app_id = sys.argv[1]
if len(sys.argv) > 2:
  host = sys.argv[2]
else:
  host = '%s.appspot.com' % app_id

remote_api_stub.ConfigureRemoteDatastore(app_id, '/remote_api', auth_func, host)

code.interact('App Engine interactive console for %s' % (app_id,), None, locals())

Mapper temel sınıfını oluşturun

Yerleştirildikten sonra bu Mapper sınıfını oluşturun. Utils.py adında yeni bir dosya oluşturdum ve şunu attım:

class Mapper(object):
  # Subclasses should replace this with a model class (eg, model.Person).
  KIND = None

  # Subclasses can replace this with a list of (property, value) tuples to filter by.
  FILTERS = []

  def map(self, entity):
    """Updates a single entity.

    Implementers should return a tuple containing two iterables (to_update, to_delete).
    """
    return ([], [])

  def get_query(self):
    """Returns a query over the specified kind, with any appropriate filters applied."""
    q = self.KIND.all()
    for prop, value in self.FILTERS:
      q.filter("%s =" % prop, value)
    q.order("__key__")
    return q

  def run(self, batch_size=100):
    """Executes the map procedure over all matching entities."""
    q = self.get_query()
    entities = q.fetch(batch_size)
    while entities:
      to_put = []
      to_delete = []
      for entity in entities:
        map_updates, map_deletes = self.map(entity)
        to_put.extend(map_updates)
        to_delete.extend(map_deletes)
      if to_put:
        db.put(to_put)
      if to_delete:
        db.delete(to_delete)
      q = self.get_query()
      q.filter("__key__ >", entities[-1].key())
      entities = q.fetch(batch_size)

Eşleştiricinin, belirli bir türdeki her varlık üzerinde yineleme yapmanıza, verilerini ayıklamanıza veya değiştirmenize ve güncellenmiş varlıkları veri deposuna geri depolamanıza izin veren yalnızca soyut bir sınıf olması beklenir.

Onunla koş!

Şimdi, uygulama motoru etkileşimli konsolunuzu başlatın:

$python appengine_console.py <app_id_here>

Bu etkileşimli konsolu başlatmalıdır. İçinde bir Model alt sınıfı oluşturun:

from utils import Mapper
# import your model class here 
class MyModelDeleter(Mapper):
    KIND = <model_name_here>

    def map(self, entity):
        return ([], [entity])

Son olarak, çalıştırın (etkileşimli konsolunuzdan): mapper = MyModelDeleter () mapper.run ()

Bu kadar!

Bunu web arayüzünü kullanarak yapabilirsiniz. Hesabınıza giriş yapın, sol taraftaki bağlantılarla gezinin. Veri Deposu yönetiminde verileri değiştirme ve silme seçeneklerine sahipsiniz. İlgili seçenekleri kullanın.

Dağıtılmış App Engine uygulamalarınızla kullanılabilecek bir eklenti paneli oluşturdum. Veri deposunda bulunan türleri bir açılır listede listeler ve belirli bir türdeki tüm varlıkları veya yalnızca her şeyi silen "görevleri" planlamak için bir düğmeyi tıklayabilirsiniz. Buradan indirebilirsiniz:
http://code.google.com/p/jobfeed/wiki/Nuke

Python için 1.3.8, bunun için yerleşik bir deneysel yönetici içerir. Onlar ki : "Lütfen app.yaml dosyasında aşağıdaki yerleşiğini etkinleştirmek:"

builtins:
- datastore_admin: on

"Datastore silme özelliği şu anda yalnızca Python çalışma zamanında kullanılabilir. Ancak Java uygulamaları, app.yaml içinde Datastore Admin'i etkinleştiren varsayılan olmayan bir Python uygulama sürümü oluşturarak bu özellikten yine de yararlanabilir. Java için yerel destek dahil edilecektir. yaklaşan bir sürümde. "

Uygulamanız için "Datastore Yöneticisi" ni açın ve Yönetici'yi etkinleştirin. Ardından tüm varlıklarınız onay kutuları ile listelenecektir. İstenmeyen girişleri seçip silebilirsiniz.

Aradığınız şey bu ...

db.delete(Entry.all(keys_only=True))

Yalnızca anahtar içeren bir sorgu çalıştırmak, tam getirmeden çok daha hızlıdır ve yalnızca anahtar sorguları küçük işlemler olarak kabul edildiğinden kotanız daha az isabet alır.

İşte Nick Johnson'dan gelen ve onu daha ayrıntılı olarak açıklayan bir cevaba bağlantı .

Aşağıda, bir tabloyu kesmek için uçtan uca bir REST API çözümü bulunmaktadır ...

Rotaların doğrudan doğru model / eylemle eşleştirildiği veritabanı işlemlerini işlemek için bir REST API kuruyorum. Bu, doğru url'yi (example.com/inventory/truncate) girip oturum açarak çağrılabilir.

İşte rota:

Route('/inventory/truncate', DataHandler, defaults={'_model':'Inventory', '_action':'truncate'})

İşte işleyici:

class DataHandler(webapp2.RequestHandler):
  @basic_auth
  def delete(self, **defaults):
    model = defaults.get('_model')
    action = defaults.get('_action')
    module = __import__('api.models', fromlist=[model])
    model_instance = getattr(module, model)()
    result = getattr(model_instance, action)()

Modeli dinamik olarak yükleyerek başlar (ör. Api.models altında bulunan Envanter), ardından eylem parametresinde belirtildiği gibi doğru yöntemi (Inventory.truncate ()) çağırır.

@Basic_auth, hassas işlemler için (yani POST / DELETE) kimlik doğrulaması sağlayan bir dekoratör / sarmalayıcıdır. Ayrıca bir oAuth dekoratörü varGüvenlik konusunda endişeleriniz varsa mevcuttur.

Son olarak, eylemin adı:

def truncate(self):
  db.delete(Inventory.all(keys_only=True))

Sihire benziyor ama aslında çok basit. En iyi yanı, delete () 'nin modele başka bir eylem ekleyerek bir veya birden çok sonucun silinmesini işlemek için yeniden kullanılabilmesidir.

Tüm Türleri Tek Tek Silerek Tüm Datastore'u Silebilirsiniz. google appengine kontrol paneli ile. Lütfen bu Adımları izleyin.

1. Https://console.cloud.google.com/datastore/settings için giriş yapın
2. Datastore Yöneticisini Aç'ı tıklayın . (Etkin değilse etkinleştirin.)
3. Tüm Varlıkları seçin ve sil düğmesine basın. (Bu Adım, tüm seçili Türleri silmek için bir harita azaltma işi çalıştırın.)

daha fazla bilgi için Bu resme bakın http://storage.googleapis.com/bnifsc/Screenshot%20from%202015-01-31%2023%3A58%3A41.png

Çok fazla veriniz varsa, web arayüzünü kullanmak zaman alıcı olabilir. App Engine Başlatıcı yardımcı programı, " Başlangıçta veri deposunu temizle" onay kutusu ile her şeyi tek seferde silmenizi sağlar. Bu yardımcı program artık hem Windows hem de Mac (Python çerçevesi) için kullanılabilir.

Geliştirme sunucusu için, sunucuyu google uygulama motoru başlatıcısı üzerinden çalıştırmak yerine terminalden şu şekilde çalıştırabilirsiniz:

dev_appserver.py --port = [portnumber] --clear_datastore = yes [uygulama adı]

örn: "okuyucu" uygulamam 15080 bağlantı noktasında çalışıyor. Kodu değiştirip sunucuyu yeniden başlattıktan sonra, sadece "dev_appserver.py --port = 15080 --clear_datastore = yes reader" komutunu çalıştırıyorum.

Bu benim için iyi.

Son gelişmeler hakkında cevap eklemek.

Google kısa süre önce veri deposu yönetici özelliğini ekledi. Bu konsolu kullanarak varlıklarınızı yedekleyebilir, silebilir veya başka bir uygulamaya kopyalayabilirsiniz.

https://developers.google.com/appengine/docs/adminconsole/datastoreadmin#Deleting_Entities_in_Bulk

Sıklıkla tüm veri deposunu silmek istemiyorum, bu yüzden kaynak kontrolünden /war/WEB-INF/local_db.bin dosyasının temiz bir kopyasını çıkarıyorum. Sadece ben olabilirim ama öyle görünüyor ki Dev Modu durdurulmuşken bile dosyayı çekmeden önce fiziksel olarak kaldırmam gerekiyor. Bu, Eclipse için subversion eklentisini kullanan Windows'ta.

PHP varyasyonu:

import com.google.appengine.api.datastore.Query;
import com.google.appengine.api.datastore.DatastoreServiceFactory;

define('DATASTORE_SERVICE', DatastoreServiceFactory::getDatastoreService());

function get_all($kind) {
    $query = new Query($kind);
    $prepared = DATASTORE_SERVICE->prepare($query);
    return $prepared->asIterable();
}

function delete_all($kind, $amount = 0) {
    if ($entities = get_all($kind)) {
        $r = $t = 0;
        $delete = array();
        foreach ($entities as $entity) {
            if ($r < 500) {
                $delete[] = $entity->getKey();
            } else {
                DATASTORE_SERVICE->delete($delete);
                $delete = array();
                $r = -1;
            }
            $r++; $t++;
            if ($amount && $amount < $t) break;
        }
        if ($delete) {
            DATASTORE_SERVICE->delete($delete);
        }
    }
}

Evet zaman alacak ve 30 sn. bir sınırdır. 30 saniyenin ötesinde otomatikleştirmek için bir ajax uygulama örneği koymayı düşünüyorum.

for amodel in db.Model.__subclasses__():
                dela=[]
                print amodel
                try:
                    m = amodel()
                    mq = m.all()
                    print mq.count()
                    for mw in mq:
                        dela.append(mw)
                    db.delete(dela)
            #~ print len(dela)

                except:
                    pass

Ndb kullanıyorsanız, veri deposunu temizlemek için benim için çalışan yöntem:

ndb.delete_multi(ndb.Query(default_options=ndb.QueryOptions(keys_only=True)))

Yerel yerine uygulama motorunda bulunan herhangi bir veri deposu için yeni Datastore API'yi kullanabilirsiniz . İşte nasıl başlayacağınıza dair bir kılavuz .

Yerleşik olmayan tüm varlıkları silen bir komut dosyası yazdım. API oldukça hızlı değişiyor, bu yüzden referans için, onu commit 990ab5c7f2063e8147bcc56ee222836fd3d6e15b'de klonladım

from gcloud import datastore
from gcloud.datastore import SCOPE
from gcloud.datastore.connection import Connection
from gcloud.datastore import query

from oauth2client import client

def get_connection():
  client_email = 'XXXXXXXX@developer.gserviceaccount.com'
  private_key_string = open('/path/to/yourfile.p12', 'rb').read()

  svc_account_credentials = client.SignedJwtAssertionCredentials(
    service_account_name=client_email,
    private_key=private_key_string,
    scope=SCOPE)

  return Connection(credentials=svc_account_credentials)


def connect_to_dataset(dataset_id):
  connection = get_connection()
  datastore.set_default_connection(connection)
  datastore.set_default_dataset_id(dataset_id)

if __name__ == "__main__":
  connect_to_dataset(DATASET_NAME)
  gae_entity_query = query.Query()
  gae_entity_query.keys_only()
  for entity in gae_entity_query.fetch():
    if entity.kind[0] != '_':
      print entity.kind
      entity.key.delete()

• svpino fikrine devam edersek, sil olarak işaretlenen kayıtları yeniden kullanmak akıllıcadır. (onun fikri kaldırmak değil, kullanılmayan kayıtları "silinmiş" olarak işaretlemekti). çalışma kopyasını işlemek için az miktarda önbellek / memcache ve veri deposuna yalnızca durumların farkını (istenen görevden önce ve sonra) yazmak onu daha iyi hale getirecektir. büyük görevler için, memcache kaybolursa veri kaybını önlemek için veri deposuna yinelemeli fark yığınları yazmak mümkündür. kayıpsız hale getirmek için memcached sonuçlarının bütünlüğünü / varlığını kontrol etmek ve eksik hesaplamaları tekrarlamak için görevi (veya gerekli kısmı) yeniden başlatmak mümkündür. veri farklılığı veri deposuna yazıldığında, gerekli hesaplamalar kuyrukta atılır.

• İndirgenmiş haritaya benzer başka bir fikir, varlık türünü birkaç farklı varlık türüne parçalamaktır, bu nedenle birlikte toplanacak ve son kullanıcıya tek varlık türü olarak görünecektir. girişler yalnızca "silindi" olarak işaretlenir. Kırık başına "silinen" giriş miktarı bir sınırın üstesinden geldiğinde, "canlı" girişler diğer parçalar arasında dağıtılır ve bu parça sonsuza kadar kapatılır ve ardından geliştirici konsolundan manuel olarak silinir (daha az maliyetle tahmin edin) upd: konsolda bırakma tablosu görünmüyor, normal fiyata yalnızca kayıt bazında silin.

• Gae başarısız olmadan (en azından yerel olarak çalışır) büyük kayıt kümelerini yığınlar halinde sorguya göre silmek mümkündür ve zaman bittiğinde bir sonraki denemeye devam etme olasılığı vardır:

    qdelete.getFetchPlan().setFetchSize(100);

    while (true)
    {
        long result = qdelete.deletePersistentAll(candidates);
        LOG.log(Level.INFO, String.format("deleted: %d", result));
        if (result <= 0)
            break;
    }

• ayrıca bazen adayları (ilgili kayıtları) ayrı bir tabloya koymak yerine birincil tabloda ek alan oluşturmak yararlı olabilir. ve evet, alan çok az hesaplama maliyeti ile indekslenmemiş / serileştirilmiş dizi olabilir.

Dev sunucusu için hızlı bir çözüme ihtiyaç duyan tüm insanlar için (Şubat 2016'da yazarken olduğu gibi):

1. Dev sunucusunu durdurun.
2. Hedefi silin dizini .
3. Projeyi yeniden oluşturun.

Bu, veri deposundaki tüm verileri silecektir.

Canlı veri deposundaki tüm verileri silmek için mevcut çözümler konusunda çok sinirliydim ki, 30 saniye içinde oldukça fazla miktarda veriyi silebilen küçük bir GAE uygulaması oluşturdum.

Vb nasıl kurulur: https://github.com/xamde/xydra

Java için

DatastoreService db = DatastoreServiceFactory.getDatastoreService();
List<Key> keys = new ArrayList<Key>();
for(Entity e : db.prepare(new Query().setKeysOnly()).asIterable())
    keys.add(e.getKey());
db.delete(keys);

Geliştirme Sunucusunda iyi çalışıyor

2 basit yolunuz var,

# 1: Maliyetten tasarruf etmek için tüm projeyi silin

# 2: ts-datastore-orm kullanarak:

https://www.npmjs.com/package/ts-datastore-orm await Entity.truncate (); Kesik, saniyede yaklaşık 1K satırı silebilir