@Override public void accept(JdbcStringBasedStoreConfigurationBuilder builder) { builder.table().read(this.table.get()); for (TwoWayKey2StringMapper mapper : ServiceLoader.load(TwoWayKey2StringMapper.class, this.module.get().getClassLoader())) { builder.key2StringMapper(mapper.getClass()); break; } builder.dialect(this.dialect).connectionFactory(DataSourceConnectionFactoryConfigurationBuilder.class).setDataSourceDependency(this.dataSource); } }
private void parseStringKeyedJdbcStore(final XMLExtendedStreamReader reader, PersistenceConfigurationBuilder persistenceBuilder) throws XMLStreamException { JdbcStringBasedStoreConfigurationBuilder builder = new JdbcStringBasedStoreConfigurationBuilder( persistenceBuilder); for (int i = 0; i < reader.getAttributeCount(); i++) { switch (attribute) { case KEY_TO_STRING_MAPPER: builder.key2StringMapper(value); break; case DIALECT: builder.dialect(DatabaseType.valueOf(value)); break; case DB_MAJOR_VERSION: builder.dbMajorVersion(Integer.parseInt(value)); break; case DB_MINOR_VERSION: builder.dbMinorVersion(Integer.parseInt(value)); break; default: switch (element) { case STRING_KEYED_TABLE: { parseTable(reader, builder.table()); break; parseConnectionPoolAttributes(reader, builder.connectionPool()); break; parseDataSourceAttributes(reader, builder.dataSource());
public void testNotCreateConnectionFactory() throws Exception { ConfigurationBuilder builder = TestCacheManagerFactory .getDefaultCacheConfiguration(false); JdbcStringBasedStoreConfigurationBuilder storeBuilder = builder .persistence() .addStore(JdbcStringBasedStoreConfigurationBuilder.class) .manageConnectionFactory(false) .dialect(DatabaseType.H2) .dbMajorVersion(1) .dbMinorVersion(4); storeBuilder.table().createOnStart(false); JdbcStringBasedStore stringBasedCacheStore = new JdbcStringBasedStore(); stringBasedCacheStore.init(createContext(builder.build())); stringBasedCacheStore.start(); assertNull(stringBasedCacheStore.getConnectionFactory()); // this will make sure that if a method like stop is called on the connection then it will barf an exception ConnectionFactory connectionFactory = mock(ConnectionFactory.class); TableManager tableManager = mock(TableManager.class); tableManager.start(); tableManager.setCacheName("otherName"); stringBasedCacheStore.initializeConnectionFactory(connectionFactory); //stop should be called even if this is an external reset(tableManager, connectionFactory); tableManager.stop(); stringBasedCacheStore.stop(); }
@Override protected EmbeddedCacheManager createCacheManager() throws Exception { ConfigurationBuilder cb = TestCacheManagerFactory.getDefaultCacheConfiguration(false); cb.persistence() .addStore(JdbcStringBasedStoreConfigurationBuilder.class) .preload(true) .key2StringMapper(LuceneKey2StringMapper.class) .table() .idColumnName("ID_COLUMN") .idColumnType("VARCHAR(255)") .tableNamePrefix("ISPN_JDBC") .dataColumnName("DATA_COLUMN") .dataColumnType("BLOB") .timestampColumnName("TIMESTAMP_COLUMN") .timestampColumnType("BIGINT") .simpleConnection() .driverClass(org.h2.Driver.class) .connectionUrl(DB_URL) .username("sa"); return TestCacheManagerFactory.createCacheManager(cb); }
static ConfigurationBuilder createCacheStoreConfig(String mapperName, boolean wrap, boolean preload) { ConfigurationBuilder cfg = TestCacheManagerFactory.getDefaultCacheConfiguration(false); JdbcStringBasedStoreConfigurationBuilder store = cfg .persistence() .addStore(JdbcStringBasedStoreConfigurationBuilder.class) .fetchPersistentState(true) .preload(preload) .key2StringMapper(mapperName); UnitTestDatabaseManager.buildTableManipulation(store.table()); if (wrap) { ConnectionFactoryConfigurationBuilder<?> tmp = UnitTestDatabaseManager.configureUniqueConnectionFactory(new ConfigurationBuilder().persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class)); store.connectionFactory(new SharedConnectionFactoryConfigurationBuilder(store)).read((PooledConnectionFactoryConfiguration)tmp.create()); } else { UnitTestDatabaseManager.configureUniqueConnectionFactory(store); } return cfg; }
private static void configureDbMeta(StoreProperties props, JdbcStringBasedStoreConfigurationBuilder builder) { props.required(DIALECT); DatabaseType type = DatabaseType.valueOf(props.get(DIALECT).toUpperCase()); builder.dialect(type); String prop; if ((prop = props.get(DB, MAJOR_VERSION)) != null) { builder.dbMajorVersion(new Integer(prop)); } if ((prop = props.get(DB, MINOR_VERSION)) != null) { builder.dbMinorVersion(new Integer(prop)); } String disableUpsert = props.get(DB, DISABLE_UPSERT); boolean upsert = Boolean.parseBoolean(disableUpsert); if (upsert) builder.addProperty(TableManagerFactory.UPSERT_DISABLED, disableUpsert); String disableIndexing = props.get(DB, DISABLE_INDEXING); boolean indexing = Boolean.parseBoolean(disableIndexing); if (indexing) builder.addProperty(TableManagerFactory.INDEXING_DISABLED, disableIndexing); }
private AbstractJdbcStoreConfigurationBuilder<?, ?> buildJdbcStore(PersistenceConfigurationBuilder loadersBuilder, OperationContext context, ModelNode store, DatabaseType databaseType) throws OperationFailedException { JdbcStringBasedStoreConfigurationBuilder builder = loadersBuilder.addStore(JdbcStringBasedStoreConfigurationBuilder.class); builder.dialect(databaseType); buildDbVersions(builder, context, store); this.buildStringKeyedTable(builder.table(), context, store.get(ModelKeys.STRING_KEYED_TABLE)); return builder; }
private void parseStringKeyedJdbcStore(final XMLExtendedStreamReader reader, PersistenceConfigurationBuilder persistenceBuilder) throws XMLStreamException { JdbcStringBasedStoreConfigurationBuilder builder = new JdbcStringBasedStoreConfigurationBuilder( persistenceBuilder); for (int i = 0; i < reader.getAttributeCount(); i++) { switch (attribute) { case KEY_TO_STRING_MAPPER: builder.key2StringMapper(value); break; default: switch (element) { case STRING_KEYED_TABLE: { parseTable(reader, builder.table()); break;
@Override public TableManipulationConfiguration get() { return new ConfigurationBuilder().persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class).table() .idColumnName(this.columns.get(ID).getKey()) .idColumnType(this.columns.get(ID).getValue()) .dataColumnName(this.columns.get(DATA).getKey()) .dataColumnType(this.columns.get(DATA).getValue()) .timestampColumnName(this.columns.get(TIMESTAMP).getKey()) .timestampColumnType(this.columns.get(TIMESTAMP).getValue()) .fetchSize(this.fetchSize) .tableNamePrefix(this.prefix) .create(); } }
@BeforeClass public void createConnection() throws Exception { JdbcStringBasedStoreConfigurationBuilder storeBuilder = TestCacheManagerFactory .getDefaultCacheConfiguration(false) .persistence() .addStore(JdbcStringBasedStoreConfigurationBuilder.class); UnitTestDatabaseManager.setDialect(storeBuilder); UnitTestDatabaseManager.buildTableManipulation(storeBuilder.table()); ConnectionFactoryConfiguration factoryConfiguration = UnitTestDatabaseManager.configureUniqueConnectionFactory(storeBuilder).create(); if (factoryConfiguration instanceof SimpleConnectionFactoryConfiguration) { SimpleConnectionFactoryConfiguration simpleConfiguration = (SimpleConnectionFactoryConfiguration) factoryConfiguration; connectionFactory = ConnectionFactory.getConnectionFactory(SimpleConnectionFactory.class); connectionFactory.start(simpleConfiguration, connectionFactory.getClass().getClassLoader()); connection = connectionFactory.getConnection(); } else if (factoryConfiguration instanceof PooledConnectionFactoryConfiguration) { PooledConnectionFactoryConfiguration pooledConfiguration = (PooledConnectionFactoryConfiguration) factoryConfiguration; connectionFactory = ConnectionFactory.getConnectionFactory(PooledConnectionFactory.class); connectionFactory.start(pooledConfiguration, connectionFactory.getClass().getClassLoader()); connection = connectionFactory.getConnection(); } tableManager = TableManagerFactory.getManager(connectionFactory, storeBuilder.create()); tableManager.setCacheName("aName"); }
public void testJdbcStringCacheStoreConfigurationAdaptor() { ConfigurationBuilder b = new ConfigurationBuilder(); b.persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class) .connectionPool() .connectionUrl(JDBC_URL) .fetchPersistentState(true) .table() .tableNamePrefix("STRINGS_") .idColumnName("id").idColumnType("VARCHAR") b.persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class).read(store); Configuration configuration2 = b.build(); JdbcStringBasedStoreConfiguration store2 = (JdbcStringBasedStoreConfiguration) configuration2.persistence().stores().get(0);
@Override protected void configurePersistence(ConfigurationBuilder cb) { JdbcStringBasedStoreConfigurationBuilder storeBuilder = cb.persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class); UnitTestDatabaseManager.configureUniqueConnectionFactory(storeBuilder); UnitTestDatabaseManager.buildTableManipulation(storeBuilder.table()); storeBuilder.segmented(true); } }
@Override protected PersistenceConfigurationBuilder createCacheStoreConfig(PersistenceConfigurationBuilder persistence, boolean preload) { JdbcStringBasedStoreConfigurationBuilder store = persistence .addStore(JdbcStringBasedStoreConfigurationBuilder.class) .preload(preload); UnitTestDatabaseManager.buildTableManipulation(store.table()); UnitTestDatabaseManager.configureUniqueConnectionFactory(store); return persistence; } }
@BeforeMethod public void beforeClass() { ConfigurationBuilder cc = TestCacheManagerFactory.getDefaultCacheConfiguration(true); JdbcStringBasedStoreConfigurationBuilder storeBuilder = cc .persistence() .addStore(JdbcStringBasedStoreConfigurationBuilder.class) .shared(true) .transactional(true); UnitTestDatabaseManager.configureUniqueConnectionFactory(storeBuilder); UnitTestDatabaseManager.setDialect(storeBuilder); UnitTestDatabaseManager.buildTableManipulation(storeBuilder.table()); cacheManager = TestCacheManagerFactory.createCacheManager(new GlobalConfigurationBuilder().defaultCacheName("Test"), cc); cache = cacheManager.getCache("Test"); store = TestingUtil.getFirstTxWriter(cache); }
@Override protected AdvancedLoadWriteStore createStore() throws Exception { ConfigurationBuilder builder = TestCacheManagerFactory.getDefaultCacheConfiguration(false); JdbcStringBasedStoreConfigurationBuilder storeBuilder = builder .persistence() .addStore(JdbcStringBasedStoreConfigurationBuilder.class); storeBuilder.dataSource() .jndiUrl(getDatasourceLocation()); UnitTestDatabaseManager.buildTableManipulation(storeBuilder.table()); JdbcStringBasedStore stringBasedCacheStore = new JdbcStringBasedStore(); stringBasedCacheStore.init(createContext(builder.build())); return stringBasedCacheStore; }
/** * The class of a {@link Key2StringMapper} to use for mapping keys to strings suitable for * storage in a database table. Defaults to {@link DefaultTwoWayKey2StringMapper} */ public JdbcStringBasedStoreConfigurationBuilder key2StringMapper(Class<? extends Key2StringMapper> klass) { key2StringMapper(klass.getName()); return this; }
public static JdbcStringBasedStoreConfigurationBuilder configureStore(StoreProperties props, JdbcStringBasedStoreConfigurationBuilder builder) { StoreType type = props.storeType(); configureDbMeta(props, builder); if (type == StoreType.JDBC_MIXED || type == StoreType.JDBC_STRING) { createTableConfig(props, STRING, builder); String mapper = props.get(KEY_TO_STRING_MAPPER); if (mapper != null) builder.key2StringMapper(props.get(KEY_TO_STRING_MAPPER)); } if (type == StoreType.JDBC_MIXED || type == StoreType.JDBC_BINARY) { createTableConfig(props, BINARY, builder); } createConnectionConfig(props, builder); builder.validate(); return builder; }
@Override public PooledConnectionFactoryConfigurationBuilder<JdbcStringBasedStoreConfigurationBuilder> connectionPool() { return JdbcStringBasedStoreConfigurationBuilder.this.connectionPool(); }
static JdbcStringBasedStoreConfiguration getStoreConfig(StoreProperties props) { JdbcStringBasedStoreConfigurationBuilder builder = new ConfigurationBuilder().persistence() .addStore(JdbcStringBasedStoreConfigurationBuilder.class); configureStore(props, builder); return builder.create(); }
throw new CacheConfigurationException(String.format("%s cannot be a target store as it no longer exists", storeType)); case JDBC_STRING: return JdbcConfigurationUtil.configureStore(props, new JdbcStringBasedStoreConfigurationBuilder(persistenceBuilder)); case ROCKSDB: props.required(LOCATION);