public void Can_Create_Blog_With_Mapper() { var connectionString = ConfigurationManager.ConnectionStrings[ConnectionStringName].ConnectionString; using (var connection = new SqlConnection(connectionString)) { connection.Open(); using (var transaction = connection.BeginTransaction()) { var metaDataStore = new MetaDataStore(); metaDataStore.BuildTableInfoFor<Blog>(); var identityMap = new IdentityMap(); var hydrater = new EntityHydrater(metaDataStore, identityMap); BlogMapper blogMapper = new BlogMapper(connection, transaction, metaDataStore, hydrater, identityMap); Blog blog = new Blog { Name = "PROMPT", Description = "Módulo 5 - Plataformas e modelos de acesso a dados" }; blog = blogMapper.Insert(blog); Assert.IsNotNull(blog); Assert.IsTrue(blog.Id > 0); Assert.AreEqual("PROMPT", blog.Name); Assert.AreEqual("Módulo 5 - Plataformas e modelos de acesso a dados", blog.Description); transaction.Commit(); } } }
public void TestInitializer() { SqlConnectionStringBuilder builder = new SqlConnectionStringBuilder(); builder.DataSource = @".\SQLEXPRESS"; builder.IntegratedSecurity = true; builder.InitialCatalog = "DBBlogs"; SqlConnection connection1 = new SqlConnection(builder.ConnectionString); connection1.Open(); _currentTransaction1 = connection1.BeginTransaction(); SqlConnection connection2 = new SqlConnection(builder.ConnectionString); connection2.Open(); _currentTransaction2 = connection2.BeginTransaction(); MetaDataStore metaDataStore = new MetaDataStore(); metaDataStore.BuildTableInfoFor<Blog>(); var identityMap1 = new IdentityMap(); var identityMap2 = new IdentityMap(); _blogMapper1 = new BlogMapper(connection1, _currentTransaction1, metaDataStore, new EntityHydrater(metaDataStore, identityMap1), identityMap1); _blogMapper2 = new BlogMapper(connection2, _currentTransaction2, metaDataStore, new EntityHydrater(metaDataStore, identityMap2), identityMap2); }
public ColumnInfo(MetaDataStore store, string name, Type dotNetType, DbType dbType, PropertyInfo propertyInfo) : base(store) { Name = name; DotNetType = dotNetType; DbType = dbType; PropertyInfo = propertyInfo; }
/// <summary> /// Initializes a new instance of the <see cref="InitializeProxyAction"/> class. /// </summary> /// <param name="connection">The connection.</param> /// <param name="transaction">The transaction.</param> /// <param name="metaDataStore">The meta data store.</param> /// <param name="hydrater">The entity hydrater.</param> /// <param name="sessionLevelCache">The session level cache.</param> public InitializeProxyAction( IDbConnection connection, IDbTransaction transaction, MetaDataStore metaDataStore, EntityHydrater hydrater, SessionLevelCache sessionLevelCache) : base(connection, transaction, metaDataStore, hydrater, sessionLevelCache) { }
/// <summary> /// Initializes a new instance of the <see cref="ReferenceInfo"/> class. /// </summary> /// <param name="store">The store.</param> /// <param name="name">The name.</param> /// <param name="referenceType">Type of the reference.</param> /// <param name="propertyInfo">The property info.</param> public ReferenceInfo(MetaDataStore store, string name, Type referenceType, PropertyInfo propertyInfo) : base(store, name, store.GetTableInfoFor(referenceType).PrimaryKey.DotNetType, store.GetTableInfoFor(referenceType).PrimaryKey.DbType, propertyInfo) { this.referenceType = referenceType; }
protected DatabaseAction(SqlConnection connection, SqlTransaction transaction, MetaDataStore metaDataStore, EntityHydrater hydrater, SessionLevelCache sessionLevelCache) { Connection = connection; Transaction = transaction; MetaDataStore = metaDataStore; Hydrater = hydrater; SessionLevelCache = sessionLevelCache; }
public void Can_FindAll_Blogs_With_Mapper() { // Prepare var connectionString = ConfigurationManager.ConnectionStrings[ConnectionStringName].ConnectionString; using (var connection = new SqlConnection(connectionString)) { connection.Open(); using (var transaction = connection.BeginTransaction()) { var metaDataStore = new MetaDataStore(); metaDataStore.BuildTableInfoFor<Blog>(); var identityMap = new IdentityMap(); var hydrater = new EntityHydrater(metaDataStore, identityMap); BlogMapper blogMapper = new BlogMapper(connection, transaction, metaDataStore, hydrater, identityMap); for (int i = 0; i < 10; i++) { Blog blog = new Blog { Name = "PROMPT " + i, Description = "Módulo " + i + " - Plataformas e modelos de acesso a dados" }; blogMapper.Insert(blog); } transaction.Commit(); } } // Test with whole new references using (var connection = new SqlConnection(connectionString)) { connection.Open(); using (var transaction = connection.BeginTransaction()) { var metaDataStore = new MetaDataStore(); metaDataStore.BuildTableInfoFor<Blog>(); var identityMap = new IdentityMap(); var hydrater = new EntityHydrater(metaDataStore, identityMap); BlogMapper blogMapper = new BlogMapper(connection, transaction, metaDataStore, hydrater, identityMap); var allBlogs = blogMapper.FindAll(); Assert.AreEqual(10, allBlogs.Count()); for (int i = 0; i < 10; i++) { int blogi = i; var blog = allBlogs.SingleOrDefault(b => b.Name == "PROMPT " + blogi); Assert.IsNotNull(blog); } transaction.Commit(); } } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Before public void setup() throws java.io.IOException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void Setup() { FileSystem = FileSystemRule.get(); DatabaseLayout = TestDirectory.databaseLayout(); // doesn't matter which version we pick we are changing it to the wrong one... MigrationTestUtils.FindFormatStoreDirectoryForVersion(StandardV2_3.STORE_VERSION, DatabaseLayout.databaseDirectory()); changeVersionNumber(FileSystem, DatabaseLayout.file(NEOSTORE_FILENAME), Version); File metadataStore = DatabaseLayout.metadataStore(); PageCache pageCache = PageCacheRule.getPageCache(FileSystem); MetaDataStore.setRecord(pageCache, metadataStore, STORE_VERSION, MetaDataStore.versionStringToLong(Version)); VersionAwareLogEntryReader <ReadableClosablePositionAwareChannel> logEntryReader = new VersionAwareLogEntryReader <ReadableClosablePositionAwareChannel>(); LogFiles logFiles = LogFilesBuilder.logFilesBasedOnlyBuilder(DatabaseLayout.databaseDirectory(), FileSystem).build(); TailScanner = new LogTailScanner(logFiles, logEntryReader, new Monitors()); }
private static void Main(string[] args) { // Traverse through every single EDS and save a snapshot of it //SaveSnapshot(); // Create dictionary of latest snapshot, argument is a list of relevant EDSs to include Dictionary <string, DatabaseMetaChange> databaseMetaChanges = MetaDataStore.GetLatestChanges(SettingsStore.EDSSettings); foreach (var databaseMetaChange in databaseMetaChanges.Values) { Console.WriteLine(databaseMetaChange); } Console.WriteLine("Done..."); Console.Read(); }
public TEntity Update <TEntity>(TEntity entity) { using (var command = CreateCommand()) { var tableInfo = MetaDataStore.GetTableInfoFor <TEntity>(); command.CommandText = tableInfo.GetUpdateStatement(); foreach (var parameterInfo in tableInfo.GetParametersForUpdate(entity)) { command.CreateAndAddInputParameter(parameterInfo.DbType, parameterInfo.Name, parameterInfo.Value); } command.ExecuteNonQuery(); return(entity); } }
internal TransactionRecordState(NeoStores neoStores, IntegrityValidator integrityValidator, RecordChangeSet recordChangeSet, long lastCommittedTxWhenTransactionStarted, ResourceLocker locks, RelationshipCreator relationshipCreator, RelationshipDeleter relationshipDeleter, PropertyCreator propertyCreator, PropertyDeleter propertyDeleter) { this._neoStores = neoStores; this._nodeStore = neoStores.NodeStore; this._relationshipStore = neoStores.RelationshipStore; this._propertyStore = neoStores.PropertyStore; this._relationshipGroupStore = neoStores.RelationshipGroupStore; this._metaDataStore = neoStores.MetaDataStore; this._schemaStore = neoStores.SchemaStore; this._integrityValidator = integrityValidator; this._recordChangeSet = recordChangeSet; this._lastCommittedTxWhenTransactionStarted = lastCommittedTxWhenTransactionStarted; this._locks = locks; this._relationshipCreator = relationshipCreator; this._relationshipDeleter = relationshipDeleter; this._propertyCreator = propertyCreator; this._propertyDeleter = propertyDeleter; }
public TEntity Insert <TEntity>(TEntity entity) { using (var command = CreateCommand()) { var tableInfo = MetaDataStore.GetTableInfoFor <TEntity>(); command.CommandText = tableInfo.GetInsertStatement(); foreach (var parameterInfo in tableInfo.GetParametersForInsert(entity)) { command.CreateAndAddInputParameter(parameterInfo.DbType, parameterInfo.Name, parameterInfo.Value); } object id = Convert.ChangeType(command.ExecuteScalar(), tableInfo.PrimaryKey.DotNetType); tableInfo.PrimaryKey.PropertyInfo.SetValue(entity, id, null); SessionLevelCache.Store(typeof(TEntity), id, entity); return(entity); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void updateOrAddNeoStoreFieldsAsPartOfMigration(org.neo4j.io.layout.DatabaseLayout migrationStructure, org.neo4j.io.layout.DatabaseLayout sourceDirectoryStructure, String versionToMigrateTo, org.neo4j.kernel.impl.transaction.log.LogPosition lastClosedTxLogPosition) throws java.io.IOException private void UpdateOrAddNeoStoreFieldsAsPartOfMigration(DatabaseLayout migrationStructure, DatabaseLayout sourceDirectoryStructure, string versionToMigrateTo, LogPosition lastClosedTxLogPosition) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.io.File storeDirNeoStore = sourceDirectoryStructure.metadataStore(); File storeDirNeoStore = sourceDirectoryStructure.MetadataStore(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.io.File migrationDirNeoStore = migrationStructure.metadataStore(); File migrationDirNeoStore = migrationStructure.MetadataStore(); fileOperation(COPY, _fileSystem, sourceDirectoryStructure, migrationStructure, Iterables.iterable(DatabaseFile.METADATA_STORE), true, ExistingTargetStrategy.SKIP); MetaDataStore.setRecord(_pageCache, migrationDirNeoStore, MetaDataStore.Position.UPGRADE_TRANSACTION_ID, MetaDataStore.getRecord(_pageCache, storeDirNeoStore, MetaDataStore.Position.LAST_TRANSACTION_ID)); MetaDataStore.setRecord(_pageCache, migrationDirNeoStore, MetaDataStore.Position.UPGRADE_TIME, DateTimeHelper.CurrentUnixTimeMillis()); // Store the checksum of the transaction id the upgrade is at right now. Store it both as // LAST_TRANSACTION_CHECKSUM and UPGRADE_TRANSACTION_CHECKSUM. Initially the last transaction and the // upgrade transaction will be the same, but imagine this scenario: // - legacy store is migrated on instance A at transaction T // - upgraded store is copied, via backup or HA or whatever to instance B // - instance A performs a transaction // - instance B would like to communicate with A where B's last transaction checksum // is verified on A. A, at this point not having logs from pre-migration era, will need to // know the checksum of transaction T to accommodate for this request from B. A will be able // to look up checksums for transactions succeeding T by looking at its transaction logs, // but T needs to be stored in neostore to be accessible. Obviously this scenario is only // problematic as long as we don't migrate and translate old logs. TransactionId lastTxInfo = ReadLastTxInformation(migrationStructure); MetaDataStore.setRecord(_pageCache, migrationDirNeoStore, MetaDataStore.Position.LAST_TRANSACTION_CHECKSUM, lastTxInfo.Checksum()); MetaDataStore.setRecord(_pageCache, migrationDirNeoStore, MetaDataStore.Position.UPGRADE_TRANSACTION_CHECKSUM, lastTxInfo.Checksum()); MetaDataStore.setRecord(_pageCache, migrationDirNeoStore, MetaDataStore.Position.LAST_TRANSACTION_COMMIT_TIMESTAMP, lastTxInfo.CommitTimestamp()); MetaDataStore.setRecord(_pageCache, migrationDirNeoStore, MetaDataStore.Position.UPGRADE_TRANSACTION_COMMIT_TIMESTAMP, lastTxInfo.CommitTimestamp()); // add LAST_CLOSED_TRANSACTION_LOG_VERSION and LAST_CLOSED_TRANSACTION_LOG_BYTE_OFFSET to the migrated // NeoStore MetaDataStore.setRecord(_pageCache, migrationDirNeoStore, MetaDataStore.Position.LAST_CLOSED_TRANSACTION_LOG_VERSION, lastClosedTxLogPosition.LogVersion); MetaDataStore.setRecord(_pageCache, migrationDirNeoStore, MetaDataStore.Position.LAST_CLOSED_TRANSACTION_LOG_BYTE_OFFSET, lastClosedTxLogPosition.ByteOffset); // Upgrade version in NeoStore MetaDataStore.setRecord(_pageCache, migrationDirNeoStore, MetaDataStore.Position.STORE_VERSION, MetaDataStore.versionStringToLong(versionToMigrateTo)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void transactionsStartedBeforeAConstraintWasCreatedAreDisallowed() public virtual void TransactionsStartedBeforeAConstraintWasCreatedAreDisallowed() { // Given NeoStores store = mock( typeof( NeoStores ) ); MetaDataStore metaDataStore = mock( typeof( MetaDataStore ) ); when( store.MetaDataStore ).thenReturn( metaDataStore ); IndexingService indexes = mock( typeof( IndexingService ) ); when( metaDataStore.LatestConstraintIntroducingTx ).thenReturn( 10L ); IntegrityValidator validator = new IntegrityValidator( store, indexes ); // When try { validator.ValidateTransactionStartKnowledge( 1 ); fail( "Should have thrown integrity error." ); } catch ( Exception ) { // good } }
public TEntity Get <TEntity>(object id) { var cachedEntity = SessionLevelCache.TryToFind(typeof(TEntity), id); if (cachedEntity != null) { return((TEntity)cachedEntity); } using (var command = CreateCommand()) { var tableInfo = MetaDataStore.GetTableInfoFor <TEntity>(); var query = tableInfo.GetSelectStatementForAllFields(); tableInfo.AddWhereByIdClause(query); command.CommandText = query.ToString(); command.CreateAndAddInputParameter(tableInfo.PrimaryKey.DbType, tableInfo.GetPrimaryKeyParameterName(), id); return(Hydrater.HydrateEntity <TEntity>(command)); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public void migrate(org.neo4j.io.layout.DatabaseLayout directoryLayout, org.neo4j.io.layout.DatabaseLayout migrationLayout, org.neo4j.kernel.impl.util.monitoring.ProgressReporter progressMonitor, String versionToMigrateFrom, String versionToMigrateTo) throws java.io.IOException public override void Migrate( DatabaseLayout directoryLayout, DatabaseLayout migrationLayout, ProgressReporter progressMonitor, string versionToMigrateFrom, string versionToMigrateTo ) { if ( CountStoreRebuildRequired( versionToMigrateFrom ) ) { // create counters from scratch fileOperation( DELETE, _fileSystem, migrationLayout, migrationLayout, _countsStoreFiles, true, null ); File neoStore = directoryLayout.MetadataStore(); long lastTxId = MetaDataStore.getRecord( _pageCache, neoStore, MetaDataStore.Position.LAST_TRANSACTION_ID ); try { RebuildCountsFromScratch( directoryLayout, migrationLayout, lastTxId, progressMonitor, versionToMigrateTo, _pageCache, NullLogProvider.Instance ); } catch ( StoreFailureException ) { //This means that we did not perform a full migration, as the formats had the same capabilities. Thus // we should use the store directory for information when rebuilding the count store. Note that we // still put the new count store in the migration directory. RebuildCountsFromScratch( directoryLayout, migrationLayout, lastTxId, progressMonitor, versionToMigrateFrom, _pageCache, NullLogProvider.Instance ); } _migrated = true; } }
/// <summary> /// Initiate static objects /// </summary> static Program() { // If debugger attached, then locate folders in solution folder. if (System.Diagnostics.Debugger.IsAttached) { ProjectPathFolder = Path.GetDirectoryName(Path.GetDirectoryName(Directory.GetCurrentDirectory())); TestDataFolder = Path.GetFullPath(Path.Combine(ProjectPathFolder, "..\\", "Data")); TestOutputFolder = Path.GetFullPath(Path.Combine(ProjectPathFolder, "..\\", "Output")); } else // Else locate in same folder as .exe file { ProjectPathFolder = AppDomain.CurrentDomain.BaseDirectory; TestDataFolder = Path.GetFullPath(Path.Combine(ProjectPathFolder, "Data")); TestOutputFolder = Path.GetFullPath(Path.Combine(ProjectPathFolder, "Output")); } SettingsStore.Init( new JsonSettingsProvider(TestDataFolder), new JsonEDSProvider() ); MetaDataStore.Init(new JSONSnapshotProvider()); }
internal virtual BranchedStoreInfo ParseBranchedStore(File branchedDatabase) { try { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.io.File neoStoreFile = org.neo4j.io.layout.DatabaseLayout.of(branchedDatabase).metadataStore(); File neoStoreFile = DatabaseLayout.of(branchedDatabase).metadataStore(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final long txId = org.neo4j.kernel.impl.store.MetaDataStore.getRecord(pageCache, neoStoreFile, org.neo4j.kernel.impl.store.MetaDataStore.Position.LAST_TRANSACTION_ID); long txId = MetaDataStore.getRecord(PageCache, neoStoreFile, MetaDataStore.Position.LAST_TRANSACTION_ID); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final long timestamp = long.Parse(branchedDatabase.getName()); long timestamp = long.Parse(branchedDatabase.Name); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final long branchedStoreSize = org.neo4j.io.fs.FileUtils.size(fileSystem, branchedDatabase); long branchedStoreSize = FileUtils.size(FileSystem, branchedDatabase); return(new BranchedStoreInfo(branchedDatabase.Name, txId, timestamp, branchedStoreSize)); } catch (IOException e) { throw new System.InvalidOperationException("Cannot read branched neostore", e); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: public synchronized void close() throws java.io.IOException public override void Close() { lock (this) { if (_asPartOfStoreCopy) { /* A checkpoint which points to the beginning of all the log files, meaning that * all the streamed transactions will be applied as part of recovery. */ long logVersion = _logFiles.LowestLogVersion; LogPosition checkPointPosition = new LogPosition(logVersion, LOG_HEADER_SIZE); _log.info("Writing checkpoint as part of store copy: " + checkPointPosition); _writer.checkPoint(checkPointPosition); // * comment copied from old StoreCopyClient * // since we just create new log and put checkpoint into it with offset equals to // LOG_HEADER_SIZE we need to update last transaction offset to be equal to this newly defined max // offset otherwise next checkpoint that use last transaction offset will be created for non // existing offset that is in most of the cases bigger than new log size. // Recovery will treat that as last checkpoint and will not try to recover store till new // last closed transaction offset will not overcome old one. Till that happens it will be // impossible for recovery process to restore the store File neoStore = _databaseLayout.metadataStore(); MetaDataStore.setRecord(_pageCache, neoStore, LAST_CLOSED_TRANSACTION_LOG_BYTE_OFFSET, checkPointPosition.ByteOffset); } _lifespan.close(); if (_lastTxId != -1) { File neoStoreFile = _databaseLayout.metadataStore(); MetaDataStore.setRecord(_pageCache, neoStoreFile, LAST_TRANSACTION_ID, _lastTxId); } _stores.close(); } }
public static object Extend(this object obj1, params object[] obj2) { IDictionary <string, object> obj_dict1 = new Dictionary <string, object>(); var tableInfo1 = MetaDataStore.GetTableInfoFor(obj1.GetType()); if (typeof(System.Dynamic.IDynamicMetaObjectProvider).IsAssignableFrom(obj1.GetType())) { // dynamic type if (obj1.GetType() == typeof(System.Dynamic.ExpandoObject)) { obj_dict1 = (IDictionary <string, object>)obj1; } } else if (typeof(IDictionary).IsAssignableFrom(obj1.GetType())) { // dictionary var p = obj1 as IDictionary; foreach (var item in p.Keys) { obj_dict1.Add(item.ToString(), p[item]); } } else { foreach (PropertyInfo pi in obj1.GetType().GetProperties()) { // Check whether the property has any information var key = pi.Name; if (tableInfo1 != null) { var ci = tableInfo1.GetColumn(pi); if (ci != null) { key = ci.Name; } } obj_dict1.Add(key, pi.GetValue(obj1, null) ?? DBNull.Value); } } foreach (var obj in obj2) { IDictionary <string, object> obj_dict2 = new Dictionary <string, object>(); var tableInfo2 = MetaDataStore.GetTableInfoFor(obj.GetType()); if (typeof(System.Dynamic.IDynamicMetaObjectProvider).IsAssignableFrom(obj.GetType())) { // dynamic type if (obj.GetType() == typeof(System.Dynamic.ExpandoObject)) { obj_dict2 = (IDictionary <string, object>)obj; } } else if (typeof(IDictionary).IsAssignableFrom(obj.GetType())) { // dictionary var p = obj as IDictionary; foreach (var item in p.Keys) { obj_dict2.Add(item.ToString(), p[item]); } } else { foreach (PropertyInfo pi in obj.GetType().GetProperties()) { // Check whether the property has any information var key = pi.Name; if (tableInfo2 != null) { var ci = tableInfo2.GetColumn(pi); if (ci != null) { key = ci.Name; } } obj_dict2.Add(key, pi.GetValue(obj, null) ?? DBNull.Value); } } // merge foreach (var key in obj_dict2.Keys) { obj_dict1.Add(key, obj_dict2[key]); } } return(obj_dict1); }
public TableInfo(MetaDataStore store, string name, Type entityType) : base(store) { Name = name; EntityType = entityType; }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void startTheDatabaseWithWrongVersionShouldFailWithUpgradeNotAllowed() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void StartTheDatabaseWithWrongVersionShouldFailWithUpgradeNotAllowed() { // given // create a store File databaseDir = _testDirectory.databaseDir(); GraphDatabaseService db = (new TestGraphDatabaseFactory()).newEmbeddedDatabase(databaseDir); using (Transaction tx = Db.beginTx()) { Db.createNode(); tx.Success(); } Db.shutdown(); // mess up the version in the metadatastore using (FileSystemAbstraction fileSystem = new DefaultFileSystemAbstraction(), ThreadPoolJobScheduler scheduler = new ThreadPoolJobScheduler(), PageCache pageCache = createPageCache(fileSystem, scheduler)) { MetaDataStore.setRecord(pageCache, _testDirectory.databaseLayout().metadataStore(), MetaDataStore.Position.STORE_VERSION, MetaDataStore.versionStringToLong("bad")); } Exception exception = assertThrows(typeof(Exception), () => (new TestGraphDatabaseFactory()).newEmbeddedDatabase(databaseDir)); assertTrue(exception.InnerException is LifecycleException); assertTrue(exception.InnerException.InnerException is System.ArgumentException); assertEquals("Unknown store version 'bad'", exception.InnerException.InnerException.Message); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static long getLastCommittedTx(org.neo4j.io.layout.DatabaseLayout databaseLayout, org.neo4j.io.pagecache.PageCache pageCache) throws java.io.IOException private static long GetLastCommittedTx(DatabaseLayout databaseLayout, PageCache pageCache) { File neoStore = databaseLayout.MetadataStore(); return(MetaDataStore.getRecord(pageCache, neoStore, MetaDataStore.Position.LAST_TRANSACTION_ID)); }
/// <summary> /// Initializes a new instance of the <see cref="MetaData"/> class. /// </summary> /// <param name="metaDataStore">The meta data store.</param> protected MetaData(MetaDataStore metaDataStore) { this.metaDataStore = metaDataStore; }
static void Main(string[] args) { string testDTSX = "LargeExample.dtsx"; string path = Path.Combine(SSISFolder, testDTSX); // Traverse through every single EDS and save a snapshot of it //foreach (EDSSettings EDS in SettingsStore.EDSSettings.Where(e => e.Name != "Template")) //{ // MetaDataSnapshot metaDataSnapshot = new MetaDataSnapshot(EDS.ConnectionString); // Console.WriteLine(metaDataSnapshot); // MetaDataStore.Provider.SaveSnapshot(EDS, metaDataSnapshot); //} // Key = EDS connection string Dictionary <string, DatabaseMetaChange> latestChanges = MetaDataStore.GetLatestChanges(SettingsStore.EDSSettings); _databaseMetaChange = latestChanges.Values.First(); //TODO: change this later. // Print out changes Console.WriteLine(_databaseMetaChange); // Create a new application to host packages, and load a package within it Application application = new Application(); Package package = application.LoadPackage(path, null); Graph g = new Graph(application, package, testDTSX, new Options.Options()) { Options = new Options.Options() }; // Print attributes, which is used in graph List <Dictionary <string, Attribute> > list = g.AttributeTable.Values.SelectMany(d => d.Values).ToList(); List <Attribute> attributes = list.SelectMany(d => d.Values).ToList(); string s = string.Join("\n", attributes.Select(a => $" -{a.Id}/{a.AttributeRef?.ID}: {a.Name}")); Console.WriteLine(s); // Iterate through all meta changes foreach (TableMetaChange tableMetaChange in _databaseMetaChange.Tables.Values) { foreach (ColumnMetaChange columnMetaChange in tableMetaChange.Columns.Values.Where(c => c.ColumnChanges > 0)) { foreach (ColumnChanges change in columnMetaChange.ListChanges()) { g.Alter(columnMetaChange, change); } } } // Validate package before saving it package.Validate(package.Connections, package.Variables, new PackageValidateErrorEvent(), null); // Save package application.SaveToXml(Path.Combine(TestOutputFolder, "packages", testDTSX), package, null); Console.WriteLine("Done"); Console.ReadKey(); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private static long lastTxChecksumOf(org.neo4j.io.layout.DatabaseLayout databaseLayout, org.neo4j.io.pagecache.PageCache pageCache) throws java.io.IOException private static long LastTxChecksumOf(DatabaseLayout databaseLayout, PageCache pageCache) { File neoStore = databaseLayout.MetadataStore(); return(MetaDataStore.getRecord(pageCache, neoStore, MetaDataStore.Position.LAST_TRANSACTION_CHECKSUM)); }
protected MetaData(MetaDataStore metaDataStore) { MetaDataStore = metaDataStore; }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void startTheDatabaseWithWrongVersionShouldFailAlsoWhenUpgradeIsAllowed() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void StartTheDatabaseWithWrongVersionShouldFailAlsoWhenUpgradeIsAllowed() { // given // create a store File databaseDirectory = _testDirectory.databaseDir(); GraphDatabaseService db = (new TestGraphDatabaseFactory()).newEmbeddedDatabase(databaseDirectory); using (Transaction tx = Db.beginTx()) { Db.createNode(); tx.Success(); } Db.shutdown(); // mess up the version in the metadatastore string badStoreVersion = "bad"; using (FileSystemAbstraction fileSystem = new DefaultFileSystemAbstraction(), ThreadPoolJobScheduler scheduler = new ThreadPoolJobScheduler(), PageCache pageCache = createPageCache(fileSystem, scheduler)) { MetaDataStore.setRecord(pageCache, _testDirectory.databaseLayout().metadataStore(), MetaDataStore.Position.STORE_VERSION, MetaDataStore.versionStringToLong(badStoreVersion)); } Exception exception = assertThrows(typeof(Exception), () => (new TestGraphDatabaseFactory()).newEmbeddedDatabaseBuilder(databaseDirectory).setConfig(GraphDatabaseSettings.allow_upgrade, "true").newGraphDatabase()); assertTrue(exception.InnerException is LifecycleException); assertTrue(exception.InnerException.InnerException is StoreUpgrader.UnexpectedUpgradingStoreVersionException); }
public void Given() { store = new MetaDataStore(null); store.BuildMetaDataFor(this.GetType().Assembly); }
public ColumnInfo(MetaDataStore store, string name, Type dotNetType, PropertyInfo propertyInfo) : this(store, name, dotNetType, TypeConverter.ToDbType(dotNetType), propertyInfo) { }
public Query(SqlCommand command, MetaDataStore metaDataStore, EntityHydrater hydrater) { this.command = command; this.metaDataStore = metaDataStore; this.hydrater = hydrater; }
public InsertAction(SqlConnection connection, SqlTransaction transaction, MetaDataStore metaDataStore, EntityHydrater hydrater, SessionLevelCache sessionLevelCache) : base(connection, transaction, metaDataStore, hydrater, sessionLevelCache) { }