Java EntityDataStore类代码示例

import io.requery.sql.EntityDataStore; //导入依赖的package包/类
@Singleton
@Provides
public EntityDataStore<Persistable> provideDatabaseSource() {
    Observable.<Void>just(null).observeOn(Schedulers.io()).subscribe(new Action1<Void>() {
        @Override
        public void call(Void aVoid) {
            raw2data(app, DB_NAME, R.raw.books);
        }
    });

    DatabaseSource source = new DatabaseSource(app, Models.DEFAULT, DB_NAME, DB_VERSION);
    source.setLoggingEnabled(BuildConfig.DEBUG);
    Configuration configuration = source.getConfiguration();

    return new EntityDataStore<>(configuration);
}
 

import io.requery.sql.EntityDataStore; //导入依赖的package包/类
@Before
public void setup() throws SQLException {
    Platform platform = new HSQL();
    CommonDataSource dataSource = DatabaseType.getDataSource(platform);
    EntityModel model = Models.MODEL2;

    Configuration configuration = new ConfigurationBuilder(dataSource, model)
        .useDefaultLogging()
        .setEntityCache(new EmptyEntityCache())
        .setWriteExecutor(Executors.newSingleThreadExecutor())
        .build();

    SchemaModifier tables = new SchemaModifier(configuration);
    tables.createTables(TableCreationMode.DROP_CREATE);
    data = new EntityDataStore<>(configuration);
}
 

import io.requery.sql.EntityDataStore; //导入依赖的package包/类
@Before
public void setup() throws SQLException {
    CommonDataSource dataSource = DatabaseType.getDataSource(new H2());
    EntityModel model = Models.JPA;

    CachingProvider provider = Caching.getCachingProvider();
    CacheManager cacheManager = provider.getCacheManager();
    Configuration configuration = new ConfigurationBuilder(dataSource, model)
        .useDefaultLogging()
        .setEntityCache(new EntityCacheBuilder(model)
            .useReferenceCache(true)
            .useSerializableCache(true)
            .useCacheManager(cacheManager)
            .build())
        .build();
    data = new EntityDataStore<>(configuration);
    SchemaModifier tables = new SchemaModifier(configuration);
    tables.dropTables();
    TableCreationMode mode = TableCreationMode.CREATE;
    System.out.println(tables.createTablesString(mode));
    tables.createTables(mode);
}
 

import io.requery.sql.EntityDataStore; //导入依赖的package包/类
@Before
public void setup() throws SQLException {
    CommonDataSource dataSource = DatabaseType.getDataSource(platform);
    EntityModel model = Models.MODEL3;

    Configuration configuration = new ConfigurationBuilder(dataSource, model)
        .useDefaultLogging()
        .setEntityCache(new EmptyEntityCache())
        .setWriteExecutor(Executors.newSingleThreadExecutor())
        .build();

    SchemaModifier tables = new SchemaModifier(configuration);
    tables.createTables(TableCreationMode.DROP_CREATE);
    System.out.println(tables.createTablesString(TableCreationMode.DROP_CREATE));
    data = new EntityDataStore<>(configuration);
}
 

import io.requery.sql.EntityDataStore; //导入依赖的package包/类
@Before
public void setup() throws SQLException {
    Platform platform = new HSQL();
    CommonDataSource dataSource = DatabaseType.getDataSource(platform);
    EntityModel model = io.requery.test.model.Models.DEFAULT;

    CachingProvider provider = Caching.getCachingProvider();
    CacheManager cacheManager = provider.getCacheManager();
    Configuration configuration = new ConfigurationBuilder(dataSource, model)
        .useDefaultLogging()
        .setWriteExecutor(Executors.newSingleThreadExecutor())
        .setEntityCache(new EntityCacheBuilder(model)
            .useReferenceCache(true)
            .useSerializableCache(true)
            .useCacheManager(cacheManager)
            .build())
        .build();

    SchemaModifier tables = new SchemaModifier(configuration);
    tables.createTables(TableCreationMode.DROP_CREATE);
    data = new ReactorEntityStore<>(new EntityDataStore<Persistable>(configuration));
}
 

import io.requery.sql.EntityDataStore; //导入依赖的package包/类
@Before
public void setup() throws SQLException {
    CommonDataSource dataSource = DatabaseType.getDataSource(platform);
    EntityModel model = Models.STATELESS;

    Configuration configuration = new ConfigurationBuilder(dataSource, model)
        .useDefaultLogging()
        .setEntityCache(new EmptyEntityCache())
        .setWriteExecutor(Executors.newSingleThreadExecutor())
        .build();

    SchemaModifier tables = new SchemaModifier(configuration);
    tables.createTables(TableCreationMode.DROP_CREATE);
    System.out.println(tables.createTablesString(TableCreationMode.DROP_CREATE));
    data = new EntityDataStore<>(configuration);
}
 

import io.requery.sql.EntityDataStore; //导入依赖的package包/类
@Before
public void setup() throws SQLException {
    CommonDataSource dataSource = DatabaseType.getDataSource(new SQLite());
    EntityModel model = Models.AUTOVALUE;
    Configuration configuration = new ConfigurationBuilder(dataSource, model)
        .useDefaultLogging()
        .setEntityCache(new EntityCacheBuilder(model)
            .useReferenceCache(true)
            .build())
        .build();
    data = new EntityDataStore<>(configuration);
    SchemaModifier tables = new SchemaModifier(configuration);
    tables.dropTables();
    TableCreationMode mode = TableCreationMode.CREATE_NOT_EXISTS;
    System.out.println(tables.createTablesString(mode));
    tables.createTables(mode);
}
 

import io.requery.sql.EntityDataStore; //导入依赖的package包/类
@Setup
public void setup() {
    EntityModel model = Models.DEFAULT;
    dataSource = (DataSource) DatabaseType.getDataSource(platform);
    data = new EntityDataStore<>(dataSource, model);
    new SchemaModifier(dataSource, model).createTables(TableCreationMode.DROP_CREATE);
    final int count = 10000;
    data.runInTransaction(new Callable<Object>() {
        @Override
        public Object call() throws Exception {
            for (int i = 0; i < count; i++) {
                Person person = FunctionalTest.randomPerson();
                data.insert(person);
            }
            return null;
        }
    });
}
 

import io.requery.sql.EntityDataStore; //导入依赖的package包/类
@Before
public void setup() throws SQLException {
    Platform platform = new HSQL();
    CommonDataSource dataSource = DatabaseType.getDataSource(platform);
    EntityModel model = io.requery.test.model.Models.DEFAULT;

    CachingProvider provider = Caching.getCachingProvider();
    CacheManager cacheManager = provider.getCacheManager();
    Configuration configuration = new ConfigurationBuilder(dataSource, model)
        .useDefaultLogging()
        .setWriteExecutor(Executors.newSingleThreadExecutor())
        .setEntityCache(new EntityCacheBuilder(model)
            .useReferenceCache(true)
            .useSerializableCache(true)
            .useCacheManager(cacheManager)
            .build())
        .build();

    SchemaModifier tables = new SchemaModifier(configuration);
    tables.createTables(TableCreationMode.DROP_CREATE);
    data = ReactiveSupport.toReactiveStore(new EntityDataStore<Persistable>(configuration));
}
 

import io.requery.sql.EntityDataStore; //导入依赖的package包/类
@Before
public void setup() throws SQLException {
    Platform platform = new HSQL();
    CommonDataSource dataSource = DatabaseType.getDataSource(platform);
    EntityModel model = io.requery.test.model.Models.DEFAULT;

    CachingProvider provider = Caching.getCachingProvider();
    CacheManager cacheManager = provider.getCacheManager();
    Configuration configuration = new ConfigurationBuilder(dataSource, model)
        .useDefaultLogging()
        .setWriteExecutor(Executors.newSingleThreadExecutor())
        .setEntityCache(new EntityCacheBuilder(model)
            .useReferenceCache(true)
            .useSerializableCache(true)
            .useCacheManager(cacheManager)
            .build())
        .build();

    SchemaModifier tables = new SchemaModifier(configuration);
    tables.createTables(TableCreationMode.DROP_CREATE);
    data = RxSupport.toReactiveStore(new EntityDataStore<Persistable>(configuration));
}
 

import io.requery.sql.EntityDataStore; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void reactiveStore() throws Exception {
  new MockUnit(Env.class, Config.class, Binder.class, EntityModel.class, Registry.class)
      .expect(newDataSource(true))
      .expect(keys)
      .expect(zeroModels).expect(noSchema)
      .expect(store(ReactiveEntityStore.class, "DEFAULT"))
      .expect(onStart)
      .expect(configurationBuilder)
      .expect(eds)
      .expect(unit -> {
        unit.mockStatic(ReactiveSupport.class);
        expect(ReactiveSupport.toReactiveStore(unit.get(EntityDataStore.class)))
            .andReturn(null);
      })
      .run(unit -> {
        Requery.reactive(unit.get(EntityModel.class))
            .configure(unit.get(Env.class), unit.get(Config.class), unit.get(Binder.class));
      }, unit -> {
        unit.captured(Throwing.Consumer.class).iterator().next()
            .accept(unit.get(Registry.class));
      });
}
 

import io.requery.sql.EntityDataStore; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void reactorStore() throws Exception {
  new MockUnit(Env.class, Config.class, Binder.class, EntityModel.class, Registry.class)
      .expect(newDataSource(true))
      .expect(keys)
      .expect(zeroModels)
      .expect(noSchema)
      .expect(store(ReactorEntityStore.class, "DEFAULT"))
      .expect(onStart)
      .expect(configurationBuilder)
      .expect(eds)
      .expect(unit -> {
        unit.constructor(ReactorEntityStore.class)
            .build(unit.get(EntityDataStore.class));
      })
      .run(unit -> {
        Requery.reactor(unit.get(EntityModel.class))
            .configure(unit.get(Env.class), unit.get(Config.class), unit.get(Binder.class));
      }, unit -> {
        unit.captured(Throwing.Consumer.class).iterator().next()
            .accept(unit.get(Registry.class));
      });
}
 

import io.requery.sql.EntityDataStore; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void completableEntityStore() throws Exception {
  new MockUnit(Env.class, Config.class, Binder.class, EntityModel.class, Registry.class)
      .expect(newDataSource(true))
      .expect(keys)
      .expect(zeroModels).expect(noSchema)
      .expect(store(CompletionStageEntityStore.class, "DEFAULT"))
      .expect(onStart)
      .expect(configurationBuilder)
      .expect(eds)
      .expect(unit -> {
        unit.constructor(CompletableEntityStore.class)
            .build(unit.get(EntityDataStore.class));
      })
      .run(unit -> {
        Requery.completionStage(unit.get(EntityModel.class))
            .configure(unit.get(Env.class), unit.get(Config.class), unit.get(Binder.class));
      }, unit -> {
        unit.captured(Throwing.Consumer.class).iterator().next()
            .accept(unit.get(Registry.class));
      });
}
 

import io.requery.sql.EntityDataStore; //导入依赖的package包/类
@NonNull
public ReactiveEntityStore<Persistable> getData() throws RuntimeException {
    if (dataStore == null) {
        // override onUpgrade to handle migrating to a new version
        DatabaseSource source = new DatabaseSource(getReflectedContext(), Models.DEFAULT, 1);
        if (BuildConfig.DEBUG) {
            // use this in development mode to drop and recreate the tables on every upgrade
            source.setTableCreationMode(TableCreationMode.DROP_CREATE);
        }
        Configuration configuration = source.getConfiguration();
        dataStore = ReactiveSupport.toReactiveStore(
                new EntityDataStore<Persistable>(configuration));
    }
    return dataStore;
}
 

import io.requery.sql.EntityDataStore; //导入依赖的package包/类
public static EntityDataStore<Persistable> getDataStore(DatabaseSource source) {
    Configuration configuration = new ConfigurationBuilder(source, Models.DEFAULT)
            .setMapping(new MainMapping())
            .setStatementCacheSize(100)
            .setEntityCache(new EntityCacheBuilder(Models.DEFAULT)
                    .useReferenceCache(true)
                    .build())
            .build();
    return new EntityDataStore<>(configuration);
}