Inheritance diagram for Deveel.Data.Sql.Tables.TableManager:

Public Member Functions
	TableManager (ITransaction transaction, ITableSourceComposite composite)

void	Dispose ()

void	Create ()
	Initializes the manager into the underlying system. More...

void	CreateTable (TableInfo tableInfo)

void	CreateTable (TableInfo tableInfo, bool temporary)

void	CreateTemporaryTable (TableInfo tableInfo)

void	SelectTable (ObjectName tableName)

void	CompactTable (ObjectName tableName)

SqlNumber	SetUniqueId (ObjectName tableName, SqlNumber value)

SqlNumber	NextUniqueId (ObjectName tableName)

bool	RealTableExists (ObjectName tableName)

bool	TableExists (ObjectName tableName)

ITable	GetTable (ObjectName tableName)

String	GetTableType (ObjectName tableName)

ObjectName	TryResolveCase (ObjectName tableName)

IMutableTable	GetMutableTable (ObjectName tableName)

TableInfo	GetTableInfo (ObjectName tableName)

bool	AlterTable (TableInfo tableInfo)

ObjectName	ResolveName (ObjectName objName, bool ignoreCase)
	Normalizes the input object name using the case sensitivity specified. More...

bool	DropTable (ObjectName tableName)

void	AssertConstraints (ObjectName tableName)

void	AddInternalTables (ITableContainer container)

IEnumerable< ObjectName >	GetTableNames ()

Package Functions
IIndexSet	GetIndexSetForTable (ITableSource tableSource)

void	RemoveVisibleTable (ITableSource table)

void	UpdateVisibleTable (TableSource table, IIndexSet indexSet)

IEnumerable< ITableSource >	GetVisibleTables ()

void	AddVisibleTables (IEnumerable< TableSource > tableSources, IEnumerable< IIndexSet > indexSets)

Properties
ITransaction	Transaction `[get, private set]`

ITableSourceComposite	Composite `[get, set]`

IEnumerable< IMutableTable >	AccessedTables `[get]`

IEnumerable< ITableSource >	SelectedTables `[get]`

bool	IgnoreIdentifiersCase `[get]`

DbObjectType IObjectManager.	ObjectType `[get]`

Properties inherited from Deveel.Data.Sql.IObjectManager
DbObjectType	ObjectType `[get]`
	Gets the type of objects managed by this instance. More...

Private Member Functions
	~TableManager ()

void	DisposeAllIndices ()

void	DisposeTouchedTables ()

void	Dispose (bool disposing)

void IObjectManager.	CreateObject (IObjectInfo objInfo)
	Create a new object of the ObjectType given the specifications given. More...

void	CopyTable (ITableSource tableSource, IIndexSet indexSet)

void	AddVisibleTable (ITableSource table, IIndexSet indexSet)

ITableSource	FindVisibleTable (ObjectName tableName, bool ignoreCase)

bool	IsDynamicTable (ObjectName tableName)

ITable	GetDynamicTable (ObjectName tableName)

string	GetDynamicTableType (ObjectName tableName)

bool IObjectManager.	RealObjectExists (ObjectName objName)
	Checks if an object really exists in the system. More...

bool IObjectManager.	ObjectExists (ObjectName objName)
	Checks if an object identified by the given name is managed by this instance. More...

IDbObject IObjectManager.	GetObject (ObjectName objName)
	Gets a database object managed by this manager. More...

ObjectName[]	GetDynamicTables ()

TableInfo	GetDynamicTableInfo (ObjectName tableName)

IMutableTable	CreateTableAtCommit (ITableSource source)

bool IObjectManager.	AlterObject (IObjectInfo objInfo)
	Modifies an existing object managed, identified by IObjectInfo.FullName component of the given specification, with the format given. More...

void	FlushTableCache (ObjectName tableName)

void	SetIndexSetForTable (ITableSource source, IIndexSet indexSet)

bool IObjectManager.	DropObject (ObjectName objName)
	Deletes a database object handled by this manager from the system. More...

Static Private Member Functions
static int	IndexOfTable (IList< ITableSource > sources, int tableId)

Private Attributes
readonly List< ITableSource >	visibleTables

List< IMutableTable >	accessedTables

List< ITableSource >	selectedTables

readonly List< IIndexSet >	tableIndices

List< ITableContainer >	internalTables

readonly Dictionary< ObjectName, IMutableTable >	tableCache

List< object >	cleanupQueue

Detailed Description

Definition at line 27 of file TableManager.cs.

Constructor & Destructor Documentation

Deveel.Data.Sql.Tables.TableManager.TableManager	(	ITransaction	transaction,
		ITableSourceComposite	composite
	)

inline

Definition at line 38 of file TableManager.cs.

                                                                                        {
             if (transaction == null)
                 throw new ArgumentNullException("transaction");
 
             Transaction = transaction;
 
             Composite = composite;
 
             visibleTables = new List<ITableSource>();
             tableIndices = new List<IIndexSet>();
             accessedTables = new List<IMutableTable>();
             tableCache = new Dictionary<ObjectName, IMutableTable>();
             selectedTables = new List<ITableSource>();
         }

Deveel.Data.Sql.Tables.TableManager.~TableManager ( )

inlineprivate

Definition at line 53 of file TableManager.cs.

                         {
             Dispose(true);
         }

Member Function Documentation

void Deveel.Data.Sql.Tables.TableManager.AddInternalTables ( ITableContainer container )

inline

Definition at line 717 of file TableManager.cs.

                                                                  {
             if (internalTables == null)
                 internalTables = new List<ITableContainer>();
 
             internalTables.Add(container);
         }

void Deveel.Data.Sql.Tables.TableManager.AddVisibleTable	(	ITableSource	table,
		IIndexSet	indexSet
	)

inlineprivate

Definition at line 307 of file TableManager.cs.

                                                                              {
             if (Transaction.ReadOnly())
                 throw new Exception("Transaction is Read-only.");
 
             visibleTables.Add(table);
             tableIndices.Add(indexSet);
         }

void Deveel.Data.Sql.Tables.TableManager.AddVisibleTables	(	IEnumerable< TableSource >	tableSources,
		IEnumerable< IIndexSet >	indexSets
	)

inlinepackage

Definition at line 728 of file TableManager.cs.

                                                                                                                 {
             var tableList = tableSources.ToList();
             var indexSetList = indexSets.ToList();
             for (int i = 0; i < tableList.Count; i++) {
                 AddVisibleTable(tableList[i], indexSetList[i]);
             }
         }

bool IObjectManager. Deveel.Data.Sql.Tables.TableManager.AlterObject ( IObjectInfo objInfo )

inlineprivate

Modifies an existing object managed, identified by IObjectInfo.FullName component of the given specification, with the format given.

Parameters

objInfo The object specification used to alter an existing object.

Returns: Returns true an object was identified and successfully altered, or false if none database object was found for the unique name given.

Exceptions

ArgumentNullException	If the given objInfo object is `null`.
ArgumentException	If the type of the object specified (IObjectInfo.ObjectType) is different than the type of objects handled by this manager.

Implements Deveel.Data.Sql.IObjectManager.

Definition at line 557 of file TableManager.cs.

                                                              {
             var tableInfo = objInfo as TableInfo;
             if (tableInfo == null)
                 throw new ArgumentException();
 
             return AlterTable(tableInfo);
         }

bool Deveel.Data.Sql.Tables.TableManager.AlterTable ( TableInfo tableInfo )

inline

Definition at line 565 of file TableManager.cs.

                                                     {
             tableInfo = tableInfo.AsReadOnly();
 
             var tableName = tableInfo.TableName;
 
             // The current schema context is the schema of the table name
             string currentSchema = tableName.Parent.Name;
             using (var session = new SystemSession(Transaction, currentSchema)) {
                 using (var context = session.CreateQuery()) {
 
                     // Get the next unique id of the unaltered table.
                     var nextId = NextUniqueId(tableName);
 
                     // Drop the current table
                     var cTable = GetTable(tableName);
                     var droppedTableId = cTable.TableInfo.Id;
 
                     DropTable(tableName);
 
                     // And create the table table
                     CreateTable(tableInfo);
 
                     var alteredTable = GetMutableTable(tableName);
                     var source = FindVisibleTable(tableName, false);
                     int alteredTableId = source.TableId;
 
                     // Set the sequence id of the table
                     source.SetUniqueId(nextId.ToInt64());
 
                     // Work out which columns we have to copy to where
                     int[] colMap = new int[tableInfo.ColumnCount];
                     var origTd = cTable.TableInfo;
                     for (int i = 0; i < colMap.Length; ++i) {
                         string colName = tableInfo[i].ColumnName;
                         colMap[i] = origTd.IndexOfColumn(colName);
                     }
 
                     // First move all the rows from the old table to the new table,
                     // This does NOT update the indexes.
                     var e = cTable.GetEnumerator();
                     while (e.MoveNext()) {
                         int rowIndex = e.Current.RowId.RowNumber;
                         var dataRow = alteredTable.NewRow();
                         for (int i = 0; i < colMap.Length; ++i) {
                             int col = colMap[i];
                             if (col != -1) {
                                 dataRow.SetValue(i, cTable.GetValue(rowIndex, col));
                             }
                         }
 
                         dataRow.SetDefault(context);
 
                         // Note we use a low level 'AddRow' method on the master table
                         // here.  This does not touch the table indexes.  The indexes are
                         // built later.
                         int newRowNumber = source.AddRow(dataRow);
 
                         // Set the record as committed added
                         source.WriteRecordState(newRowNumber, RecordState.CommittedAdded);
                     }
 
                     // TODO: We need to copy any existing index definitions that might
                     //   have been set on the table being altered.
 
                     // Rebuild the indexes in the new master table,
                     source.BuildIndexes();
 
                     // Get the snapshot index set on the new table and set it here
                     SetIndexSetForTable(source, source.CreateIndexSet());
 
                     // Flush this out of the table cache
                     FlushTableCache(tableName);
 
                     // Ensure the native sequence generator exists...
                     Transaction.RemoveNativeSequence(tableName);
                     Transaction.CreateNativeSequence(tableName);
 
                     // Notify that this database object has been successfully dropped and
                     // created.
                     Transaction.Registry.RegisterEvent(new TableDroppedEvent(droppedTableId, tableName));
                     Transaction.Registry.RegisterEvent(new TableCreatedEvent(alteredTableId, tableName));
 
                     return true;
                 }
             }
         }

void Deveel.Data.Sql.Tables.TableManager.AssertConstraints ( ObjectName tableName )

inline

Definition at line 713 of file TableManager.cs.

                                                             {
             throw new NotImplementedException();
         }

void Deveel.Data.Sql.Tables.TableManager.CompactTable ( ObjectName tableName )

inline

Definition at line 258 of file TableManager.cs.

                                                        {
             // Find the master table.
             var currentTable = FindVisibleTable(tableName, false);
             if (currentTable == null)
                 throw new ObjectNotFoundException(tableName);
 
             // If the table is worth compacting
             if (currentTable.CanCompact) {
                 // The view of this table within this transaction.
                 var indexSet = GetIndexSetForTable(currentTable);
 
                 // Drop the current table
                 DropTable(tableName);
 
                 // And copy to the new table
                 CopyTable(currentTable, indexSet);
             }
         }

void Deveel.Data.Sql.Tables.TableManager.CopyTable	(	ITableSource	tableSource,
		IIndexSet	indexSet
	)

inlineprivate

Definition at line 277 of file TableManager.cs.

                                                                              {
             var tableInfo = tableSource.TableInfo;
             var tableName = tableInfo.TableName;
             var source = FindVisibleTable(tableName, false);
             if (source != null)
                 throw new ObjectNotFoundException(tableName);
 
             // Copy the table and add to the list of visible tables.
             source = Composite.CopySourceTable(tableSource, indexSet);
 
             AddVisibleTable(source, source.CreateIndexSet());
 
             // Log in the journal that this transaction touched the table_id.
             int tableId = source.TableId;
             Transaction.Registry.RegisterEvent(new TableCreatedEvent(tableId, tableName));
 
             Transaction.CreateNativeSequence(tableName);
         }

void Deveel.Data.Sql.Tables.TableManager.Create ( )

inline

Initializes the manager into the underlying system.

Typically this method generates the tables required to manage the features relative to the objects.

Implements Deveel.Data.Sql.IObjectManager.

Definition at line 135 of file TableManager.cs.

                              {
             // SYSTEM.PKEY_INFO
             var tableInfo = new TableInfo(SystemSchema.PrimaryKeyInfoTableName);
             tableInfo.AddColumn("id", PrimitiveTypes.Numeric());
             tableInfo.AddColumn("name", PrimitiveTypes.String());
             tableInfo.AddColumn("schema", PrimitiveTypes.String());
             tableInfo.AddColumn("table", PrimitiveTypes.String());
             tableInfo.AddColumn("deferred", PrimitiveTypes.Numeric());
             tableInfo = tableInfo.AsReadOnly();
             Transaction.CreateTable(tableInfo);
 
             // SYSTEM.PKEY_COLS
             tableInfo = new TableInfo(SystemSchema.PrimaryKeyColumnsTableName);
             tableInfo.AddColumn("pk_id", PrimitiveTypes.Numeric());
             tableInfo.AddColumn("column", PrimitiveTypes.String());
             tableInfo.AddColumn("seq_no", PrimitiveTypes.Numeric());
             tableInfo = tableInfo.AsReadOnly();
             Transaction.CreateTable(tableInfo);
 
             // SYSTEM.FKEY_INFO
             tableInfo = new TableInfo(SystemSchema.ForeignKeyInfoTableName);
             tableInfo.AddColumn("id", PrimitiveTypes.Numeric());
             tableInfo.AddColumn("name", PrimitiveTypes.String());
             tableInfo.AddColumn("schema", PrimitiveTypes.String());
             tableInfo.AddColumn("table", PrimitiveTypes.String());
             tableInfo.AddColumn("ref_schema", PrimitiveTypes.String());
             tableInfo.AddColumn("ref_table", PrimitiveTypes.String());
             tableInfo.AddColumn("update_rule", PrimitiveTypes.Numeric());
             tableInfo.AddColumn("delete_rule", PrimitiveTypes.Numeric());
             tableInfo.AddColumn("deferred", PrimitiveTypes.Numeric());
             tableInfo = tableInfo.AsReadOnly();
             Transaction.CreateTable(tableInfo);
 
             // SYSTEM.FKEY_COLS
             tableInfo = new TableInfo(SystemSchema.ForeignKeyColumnsTableName);
             tableInfo.AddColumn("fk_id", PrimitiveTypes.Numeric());
             tableInfo.AddColumn("fcolumn", PrimitiveTypes.String());
             tableInfo.AddColumn("pcolumn", PrimitiveTypes.String());
             tableInfo.AddColumn("seq_no", PrimitiveTypes.Numeric());
             tableInfo = tableInfo.AsReadOnly();
             Transaction.CreateTable(tableInfo);
 
             // SYSTEM.UNIQUE_INFO
             tableInfo = new TableInfo(SystemSchema.UniqueKeyInfoTableName);
             tableInfo.AddColumn("id", PrimitiveTypes.Numeric());
             tableInfo.AddColumn("name", PrimitiveTypes.String());
             tableInfo.AddColumn("schema", PrimitiveTypes.String());
             tableInfo.AddColumn("table", PrimitiveTypes.String());
             tableInfo.AddColumn("deferred", PrimitiveTypes.Numeric());
             tableInfo = tableInfo.AsReadOnly();
             Transaction.CreateTable(tableInfo);
 
             // SYSTEM.UNIQUE_COLS
             tableInfo = new TableInfo(SystemSchema.UniqueKeyColumnsTableName);
             tableInfo.AddColumn("un_id", PrimitiveTypes.Numeric());
             tableInfo.AddColumn("column", PrimitiveTypes.String());
             tableInfo.AddColumn("seq_no", PrimitiveTypes.Numeric());
             tableInfo = tableInfo.AsReadOnly();
             Transaction.CreateTable(tableInfo);
 
             // SYSTEM.CHECK_INFO
             tableInfo = new TableInfo(SystemSchema.CheckInfoTableName);
             tableInfo.AddColumn("id", PrimitiveTypes.Numeric());
             tableInfo.AddColumn("name", PrimitiveTypes.String());
             tableInfo.AddColumn("schema", PrimitiveTypes.String());
             tableInfo.AddColumn("table", PrimitiveTypes.String());
             tableInfo.AddColumn("expression", PrimitiveTypes.String());
             tableInfo.AddColumn("deferred", PrimitiveTypes.Numeric());
             tableInfo.AddColumn("serialized_expression", PrimitiveTypes.Binary());
             tableInfo = tableInfo.AsReadOnly();
             Transaction.CreateTable(tableInfo);
         }

void IObjectManager. Deveel.Data.Sql.Tables.TableManager.CreateObject ( IObjectInfo objInfo )

inlineprivate

Create a new object of the ObjectType given the specifications given.

Parameters

objInfo The object specifications used to create a new object.

Exceptions

ArgumentNullException	If the given objInfo is `null`.
ArgumentException	If the object type of the specification (IObjectInfo.ObjectType) is different than the ObjectType of this manager.

Implements Deveel.Data.Sql.IObjectManager.

Definition at line 208 of file TableManager.cs.

                                                               {
             var tableInfo = objInfo as TableInfo;
             if (tableInfo == null)
                 throw new ArgumentException();
 
             CreateTable(tableInfo);
         }

void Deveel.Data.Sql.Tables.TableManager.CreateTable ( TableInfo tableInfo )

inline

Definition at line 216 of file TableManager.cs.

                                                      {
             CreateTable(tableInfo, false);
         }

void Deveel.Data.Sql.Tables.TableManager.CreateTable	(	TableInfo	tableInfo,
		bool	temporary
	)

inline

Definition at line 220 of file TableManager.cs.

                                                                      {
             var tableName = tableInfo.TableName;
             var source = FindVisibleTable(tableName, false);
             if (source != null)
                 throw new InvalidOperationException(String.Format("Table '{0}' already exists.", tableName));
 
             tableInfo = tableInfo.AsReadOnly();
 
             source = Composite.CreateTableSource(tableInfo, temporary);
 
             // Add this table (and an index set) for this table.
             AddVisibleTable(source, source.CreateIndexSet());
 
             int tableId = source.TableId;
             Transaction.Registry.RegisterEvent(new TableCreatedEvent(tableId, tableName));
 
             Transaction.CreateNativeSequence(tableName);
         }

IMutableTable Deveel.Data.Sql.Tables.TableManager.CreateTableAtCommit ( ITableSource source )

inlineprivate

Definition at line 546 of file TableManager.cs.

                                                                        {
             // Create the table for this transaction.
             var table = source.CreateTableAtCommit(Transaction);
 
             accessedTables.Add(table);
 
             Transaction.Registry.RegisterEvent(new TableAccessEvent(source.TableId, source.TableInfo.TableName));
 
             return table;
         }

void Deveel.Data.Sql.Tables.TableManager.CreateTemporaryTable ( TableInfo tableInfo )

inline

Definition at line 239 of file TableManager.cs.

                                                               {
             CreateTable(tableInfo, true);
         }

void Deveel.Data.Sql.Tables.TableManager.Dispose ( )

inline

Definition at line 77 of file TableManager.cs.

                               {
             Dispose(true);
             GC.SuppressFinalize(this);
         }

void Deveel.Data.Sql.Tables.TableManager.Dispose ( bool disposing )

inlineprivate

Definition at line 122 of file TableManager.cs.

                                              {
             if (disposing) {
                 DisposeAllIndices();
                 DisposeTouchedTables();
             }
 
             Transaction = null;
         }

void Deveel.Data.Sql.Tables.TableManager.DisposeAllIndices ( )

inlineprivate

Definition at line 82 of file TableManager.cs.

                                          {
             // Dispose all the IIndexSet for each table
             try {
                 foreach (var tableIndex in tableIndices) {
                     tableIndex.Dispose();
                 }
             } catch (Exception) {
                 // TODO: Report the error ...
             }
 
             // Dispose all tables we dropped (they will be in the cleanup_queue.
             try {
                 if (cleanupQueue != null) {
                     for (int i = 0; i < cleanupQueue.Count; i += 2) {
                         var tableSource = (TableSource) cleanupQueue[i];
                         IIndexSet indexSet = (IIndexSet) cleanupQueue[i + 1];
                         indexSet.Dispose();
                     }
                 }
             } catch (Exception) {
                 // TODO: Report the error
             } finally {
                 cleanupQueue = null;
             }
         }

void Deveel.Data.Sql.Tables.TableManager.DisposeTouchedTables ( )

inlineprivate

Definition at line 108 of file TableManager.cs.

                                             {
             try {
                 foreach (var table in accessedTables) {
                     table.Dispose();
                 }
 
                 accessedTables.Clear();
             } catch (Exception) {
                 // TODO: Report the error
             } finally {
                 accessedTables = null;
             }
         }

bool IObjectManager. Deveel.Data.Sql.Tables.TableManager.DropObject ( ObjectName objName )

inlineprivate

Deletes a database object handled by this manager from the system.

Parameters

objName The unique name of the object to be deleted.

Returns: Returns true if a database object was found with the given unique name and successfully deleted from the system, or false if none object was found.

Implements Deveel.Data.Sql.IObjectManager.

Definition at line 669 of file TableManager.cs.

                                                            {
             return DropTable(objName);
         }

bool Deveel.Data.Sql.Tables.TableManager.DropTable ( ObjectName tableName )

inline

Definition at line 696 of file TableManager.cs.

                                                     {
             var source = FindVisibleTable(tableName, false);
             if (source == null)
                 return false;
 
             // Removes this table from the visible table list of this transaction
             RemoveVisibleTable(source);
 
             // Log in the journal that this transaction touched the table_id.
             int tableId = source.TableId;
             Transaction.Registry.RegisterEvent(new TableDroppedEvent(tableId, tableName));
 
             Transaction.RemoveNativeSequence(tableName);
 
             return true;
         }

ITableSource Deveel.Data.Sql.Tables.TableManager.FindVisibleTable	(	ObjectName	tableName,
		bool	ignoreCase
	)

inlineprivate

Definition at line 354 of file TableManager.cs.

                                                                                      {
             return visibleTables
                 .FirstOrDefault(source => source != null &&
                                           source.TableInfo.TableName.Equals(tableName, ignoreCase));
         }

void Deveel.Data.Sql.Tables.TableManager.FlushTableCache ( ObjectName tableName )

inlineprivate

Definition at line 653 of file TableManager.cs.

                                                        {
             tableCache.Remove(tableName);
         }

ITable Deveel.Data.Sql.Tables.TableManager.GetDynamicTable ( ObjectName tableName )

inlineprivate

Definition at line 387 of file TableManager.cs.

                                                              {
             foreach (var info in internalTables) {
                 if (info != null) {
                     int index = info.FindByName(tableName);
                     if (index != -1)
                         return info.GetTable(index);
                 }
             }
 
             throw new ArgumentException(String.Format("Table '{0}' is not a dynamic table.", tableName));
         }

TableInfo Deveel.Data.Sql.Tables.TableManager.GetDynamicTableInfo ( ObjectName tableName )

inlineprivate

Definition at line 523 of file TableManager.cs.

                                                                     {
             foreach (var info in internalTables) {
                 if (info != null) {
                     int index = info.FindByName(tableName);
                     if (index != -1)
                         return info.GetTableInfo(index);
                 }
             }
 
             throw new Exception("Not an internal table: " + tableName);
         }

ObjectName [] Deveel.Data.Sql.Tables.TableManager.GetDynamicTables ( )

inlineprivate

Definition at line 469 of file TableManager.cs.

                                                 {
             int sz = internalTables.Where(container => container != null).Sum(container => container.TableCount);
 
             var list = new ObjectName[sz];
             int index = -1;
 
             foreach (var container in internalTables) {
                 if (container != null) {
                     int tableCount = container.TableCount;
                     for (int i = 0; i < tableCount; ++i) {
                         list[++index] = container.GetTableName(i);
                     }
                 }
             }
 
             return list;
         }

string Deveel.Data.Sql.Tables.TableManager.GetDynamicTableType ( ObjectName tableName )

inlineprivate

Definition at line 399 of file TableManager.cs.

                                                                  {
             // Otherwise we need to look up the table in the internal table list,
             foreach (var info in internalTables) {
                 if (info != null) {
                     int index = info.FindByName(tableName);
                     if (index != -1)
                         return info.GetTableType(index);
                 }
             }
 
             throw new ArgumentException(String.Format("Table '{0}' is not a dynamic table.", tableName));
         }

IIndexSet Deveel.Data.Sql.Tables.TableManager.GetIndexSetForTable ( ITableSource tableSource )

inlinepackage

Definition at line 296 of file TableManager.cs.

                                                                          {
             int sz = tableIndices.Count;
             for (int i = 0; i < sz; ++i) {
                 if (visibleTables[i].TableId == tableSource.TableId) {
                     return tableIndices[i];
                 }
             }
 
             throw new Exception("Table source not found in this transaction.");
         }

IMutableTable Deveel.Data.Sql.Tables.TableManager.GetMutableTable ( ObjectName tableName )

inline

Definition at line 512 of file TableManager.cs.

                                                                    {
             var table = GetTable(tableName);
             if (table == null)
                 return null;
 
             if (!(table is IMutableTable))
                 throw new InvalidOperationException();
 
             return (IMutableTable) table;
         }

IDbObject IObjectManager. Deveel.Data.Sql.Tables.TableManager.GetObject ( ObjectName objName )

inlineprivate

Gets a database object managed by this manager.

Parameters

objName The name that uniquely identifies the object to get.

Returns: Returns a IDbObject instance that is identified by the given unique name, or null if this manager was not able to map any object to the name specified.

Implements Deveel.Data.Sql.IObjectManager.

Definition at line 429 of file TableManager.cs.

                                                                {
             return GetTable(objName);
         }

ITable Deveel.Data.Sql.Tables.TableManager.GetTable ( ObjectName tableName )

inline

Definition at line 433 of file TableManager.cs.

                                                      {
             // If table is in the cache, return it
             IMutableTable table;
             if (tableCache.TryGetValue(tableName, out table))
                 return table;
 
             var source = FindVisibleTable(tableName, false);
 
             if (source == null) {
                 if (IsDynamicTable(tableName))
                     return GetDynamicTable(tableName);
             } else {
                 // Otherwise make a view of tha master table data source and write it in
                 // the cache.
                 table = CreateTableAtCommit(source);
 
                 // Put table name in the cache
                 tableCache[tableName] = table;
             }
 
             return table;
         }

TableInfo Deveel.Data.Sql.Tables.TableManager.GetTableInfo ( ObjectName tableName )

inline

Definition at line 535 of file TableManager.cs.

                                                             {
             // If this is a dynamic table then handle specially
             if (IsDynamicTable(tableName))
                 return GetDynamicTableInfo(tableName);
 
             // Otherwise return from the pool of visible tables
             return visibleTables
                 .Select(table => table.TableInfo)
                 .FirstOrDefault(tableInfo => tableInfo.TableName.Equals(tableName));
         }

IEnumerable<ObjectName> Deveel.Data.Sql.Tables.TableManager.GetTableNames ( )

inline

Definition at line 736 of file TableManager.cs.

                                                        {
             var result = (visibleTables
                 .Where(tableSource => tableSource != null)
                 .Select(tableSource => tableSource.TableInfo.TableName)).ToList();
 
             var dynamicTables = GetDynamicTables();
             if (dynamicTables != null)
                 result.AddRange(dynamicTables);
 
             return result.ToArray();
         }

String Deveel.Data.Sql.Tables.TableManager.GetTableType ( ObjectName tableName )

inline

Definition at line 456 of file TableManager.cs.

                                                          {
             if (tableName == null)
                 throw new ArgumentNullException("tableName");
 
             if (IsDynamicTable(tableName))
                 return GetDynamicTableType(tableName);
             if (FindVisibleTable(tableName, false) != null)
                 return TableTypes.Table;
 
             // No table found so report the error.
             throw new ObjectNotFoundException(tableName);
         }

IEnumerable<ITableSource> Deveel.Data.Sql.Tables.TableManager.GetVisibleTables ( )

inlinepackage

Definition at line 724 of file TableManager.cs.

                                                               {
             return visibleTables.ToArray();
         }

static int Deveel.Data.Sql.Tables.TableManager.IndexOfTable	(	IList< ITableSource >	sources,
		int	tableId
	)

inlinestaticprivate

Definition at line 315 of file TableManager.cs.

                                                                                   {
             for (int i = 0; i < sources.Count; i++) {
                 var source = sources[i];
                 if (source.TableId == tableId)
                     return i;
             }
 
             return -1;
         }

bool Deveel.Data.Sql.Tables.TableManager.IsDynamicTable ( ObjectName tableName )

inlineprivate

Definition at line 380 of file TableManager.cs.

                                                           {
             if (internalTables == null)
                 return false;
 
             return internalTables.Any(info => info != null && info.ContainsTable(tableName));
         }

SqlNumber Deveel.Data.Sql.Tables.TableManager.NextUniqueId ( ObjectName tableName )

inline

Definition at line 370 of file TableManager.cs.

                                                             {
             var tableSource = FindVisibleTable(tableName, false);
             if (tableSource == null)
                 throw new ObjectNotFoundException(tableName,
                     String.Format("Table with name '{0}' could not be found to retrieve unique id.", tableName));
 
             var value = tableSource.GetNextUniqueId();
             return new SqlNumber(value);
         }

bool IObjectManager. Deveel.Data.Sql.Tables.TableManager.ObjectExists ( ObjectName objName )

inlineprivate

Checks if an object identified by the given name is managed by this instance.

Parameters

objName The name that uniquely identifies the object.

Returns

Implements Deveel.Data.Sql.IObjectManager.

Definition at line 420 of file TableManager.cs.

                                                              {
             return TableExists(objName);
         }

bool IObjectManager. Deveel.Data.Sql.Tables.TableManager.RealObjectExists ( ObjectName objName )

inlineprivate

Checks if an object really exists in the system.

Parameters

objName The unique name of the object to check.

Returns: Returns true if an object with the given name concretely exists in the system, or false otherwise.

Implements Deveel.Data.Sql.IObjectManager.

Definition at line 412 of file TableManager.cs.

                                                                  {
             return RealTableExists(objName);
         }

bool Deveel.Data.Sql.Tables.TableManager.RealTableExists ( ObjectName tableName )

inline

Definition at line 416 of file TableManager.cs.

                                                           {
             return FindVisibleTable(tableName, false) != null;
         }

void Deveel.Data.Sql.Tables.TableManager.RemoveVisibleTable ( ITableSource table )

inlinepackage

Definition at line 325 of file TableManager.cs.

                                                              {
             if (Transaction.ReadOnly())
                 throw new Exception("Transaction is Read-only.");
 
             var i = IndexOfTable(visibleTables, table.TableId);
             if (i != -1) {
                 visibleTables.RemoveAt(i);
                 IIndexSet indexSet = tableIndices[i];
                 tableIndices.RemoveAt(i);
                 if (cleanupQueue == null)
                     cleanupQueue = new List<object>();
 
                 cleanupQueue.Add(table);
                 cleanupQueue.Add(indexSet);
 
                 // Remove from the table cache
                 var tableName = table.TableInfo.TableName;
                 tableCache.Remove(tableName);
             }
         }

ObjectName Deveel.Data.Sql.Tables.TableManager.ResolveName	(	ObjectName	objName,
		bool	ignoreCase
	)

inline

Normalizes the input object name using the case sensitivity specified.

Parameters

objName	The input object name, that can be partial or complete, to be normalized to the real name of an object.
ignoreCase	The case sensitivity specification used to compare the input name with the names of the existing objects handled by this manager.

Returns: Returns the fully normalized ObjectName that is the real name of an object matching the input name, or null if the input name was not possible to be resolved.

Implements Deveel.Data.Sql.IObjectManager.

Definition at line 673 of file TableManager.cs.

                                                                            {
             // Is it a visible table (match case insensitive)
             var table = FindVisibleTable(objName, ignoreCase);
             if (table != null)
                 return table.TableInfo.TableName;
 
             // Is it an internal table?
             string tschema = objName.ParentName;
             string tname = objName.Name;
             var list = GetDynamicTables();
 
             var comparison = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;
             foreach (var ctable in list) {
                 if (String.Equals(ctable.ParentName, tschema, comparison) &&
                     String.Equals(ctable.Name, tname, comparison)) {
                     return ctable;
                 }
             }
 
             // No matches so return the original object.
             return objName;
         }

void Deveel.Data.Sql.Tables.TableManager.SelectTable ( ObjectName tableName )

inline

Definition at line 243 of file TableManager.cs.

                                                       {
             // Special handling of internal tables,
             if (IsDynamicTable(tableName))
                 return;
 
             var source = FindVisibleTable(tableName, false);
             if (source == null)
                 throw new ObjectNotFoundException(tableName);
 
             lock (selectedTables) {
                 if (!selectedTables.Contains(source))
                     selectedTables.Add(source);
             }
         }

void Deveel.Data.Sql.Tables.TableManager.SetIndexSetForTable	(	ITableSource	source,
		IIndexSet	indexSet
	)

inlineprivate

Definition at line 657 of file TableManager.cs.

                                                                                   {
             int sz = tableIndices.Count;
             for (int i = 0; i < sz; ++i) {
                 if (visibleTables[i].TableId == source.TableId) {
                     tableIndices[i] = indexSet;
                     return;
                 }
             }
 
             throw new Exception("Table source not found in this transaction.");
         }

SqlNumber Deveel.Data.Sql.Tables.TableManager.SetUniqueId	(	ObjectName	tableName,
		SqlNumber	value
	)

inline

Definition at line 360 of file TableManager.cs.

                                                                             {
             var tableSource = FindVisibleTable(tableName, false);
             if (tableSource == null)
                 throw new ObjectNotFoundException(tableName,
                     String.Format("Table with name '{0}' could not be found to set the unique id.", tableName));
 
             tableSource.SetUniqueId(value.ToInt64());
             return value;
         }

bool Deveel.Data.Sql.Tables.TableManager.TableExists ( ObjectName tableName )

inline

Definition at line 424 of file TableManager.cs.

                                                       {
             return IsDynamicTable(tableName) ||
                    RealTableExists(tableName);
         }

ObjectName Deveel.Data.Sql.Tables.TableManager.TryResolveCase ( ObjectName tableName )

inline

Definition at line 487 of file TableManager.cs.

                                                                {
             // Is it a visable table (match case insensitive)
             var table = FindVisibleTable(tableName, true);
             if (table != null)
                 return table.TableInfo.TableName;
 
             var comparison = IgnoreIdentifiersCase
                 ? StringComparison.OrdinalIgnoreCase
                 : StringComparison.Ordinal;
 
             // Is it an internal table?
             string tschema = tableName.ParentName;
             string tname = tableName.Name;
             var list = GetDynamicTables();
             foreach (var ctable in list) {
                 if (String.Equals(ctable.ParentName, tschema, comparison) &&
                     String.Equals(ctable.Name, tname, comparison)) {
                     return ctable;
                 }
             }
 
             // No matches so return the original object.
             return tableName;
         }

void Deveel.Data.Sql.Tables.TableManager.UpdateVisibleTable	(	TableSource	table,
		IIndexSet	indexSet
	)

inlinepackage

Definition at line 346 of file TableManager.cs.

                                                                                 {
             if (Transaction.ReadOnly())
                 throw new Exception("Transaction is Read-only.");
 
             RemoveVisibleTable(table);
             AddVisibleTable(table, indexSet);
         }

Member Data Documentation

List<IMutableTable> Deveel.Data.Sql.Tables.TableManager.accessedTables

private

Definition at line 29 of file TableManager.cs.

List<object> Deveel.Data.Sql.Tables.TableManager.cleanupQueue

private

Definition at line 36 of file TableManager.cs.

List<ITableContainer> Deveel.Data.Sql.Tables.TableManager.internalTables

private

Definition at line 32 of file TableManager.cs.

List<ITableSource> Deveel.Data.Sql.Tables.TableManager.selectedTables

private

Definition at line 30 of file TableManager.cs.

readonly Dictionary<ObjectName, IMutableTable> Deveel.Data.Sql.Tables.TableManager.tableCache

private

Definition at line 34 of file TableManager.cs.

readonly List<IIndexSet> Deveel.Data.Sql.Tables.TableManager.tableIndices

private

Definition at line 31 of file TableManager.cs.

readonly List<ITableSource> Deveel.Data.Sql.Tables.TableManager.visibleTables

private

Definition at line 28 of file TableManager.cs.

Property Documentation

IEnumerable<IMutableTable> Deveel.Data.Sql.Tables.TableManager.AccessedTables

getpackage

Definition at line 61 of file TableManager.cs.

ITableSourceComposite Deveel.Data.Sql.Tables.TableManager.Composite

getsetprivate

Definition at line 59 of file TableManager.cs.

bool Deveel.Data.Sql.Tables.TableManager.IgnoreIdentifiersCase

getprivate

Definition at line 73 of file TableManager.cs.

DbObjectType IObjectManager. Deveel.Data.Sql.Tables.TableManager.ObjectType

getprivate

Definition at line 131 of file TableManager.cs.

IEnumerable<ITableSource> Deveel.Data.Sql.Tables.TableManager.SelectedTables

getpackage

Definition at line 65 of file TableManager.cs.

ITransaction Deveel.Data.Sql.Tables.TableManager.Transaction

getprivate set

Definition at line 57 of file TableManager.cs.

The documentation for this class was generated from the following file:

/var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb/Deveel.Data.Sql.Tables/TableManager.cs

Public Member Functions

Package Functions

Properties

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation