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

Classes
class	TableGroupResolver

Public Member Functions
	FunctionTable (SqlExpression[] functionList, string[] columnNames, IRequest queryContext)

	FunctionTable (ITable table, SqlExpression[] functionList, string[] columnNames, IRequest queryContext)

override IEnumerator< Row >	GetEnumerator ()

override void	Lock ()

override void	Release ()

override DataObject	GetValue (long rowNumber, int columnOffset)
	Gets a single cell within the table that is located at the given column offset and row. More...

ITable	MergeWith (ObjectName maxColumn)

FunctionTable	AsGroup ()

FunctionTable	CreateGroupMatrix (ObjectName[] columns)

Public Member Functions inherited from Deveel.Data.Sql.Tables.BaseDataTable
void	AddToIndex (int rowNumber, int columnNumber)

void	AddRowToIndex (int rowNumber)

void	RemoveRowFromIndex (int rowNumber)

Public Member Functions inherited from Deveel.Data.Sql.Tables.RootTable
bool	TypeEquals (IRootTable other)

Public Member Functions inherited from Deveel.Data.Sql.Tables.Table
void	Dispose ()

ColumnIndex	GetIndex (int columnOffset)
	Gets an index for given column that can be used to select values from this table. More...

Static Public Member Functions
static ITable	ResultTable (IRequest context, SqlExpression expression)

static ITable	ResultTable (IRequest context, DataObject value)

static ITable	ResultTable (IRequest context, int value)

Properties
ITable	ReferenceTable `[get, private set]`

override TableInfo	TableInfo `[get]`

override int	RowCount `[get]`

Properties inherited from Deveel.Data.Sql.Tables.BaseDataTable
override IContext	Context `[get]`

Properties inherited from Deveel.Data.Sql.Tables.RootTable
ObjectName	TableName `[get]`

Properties inherited from Deveel.Data.Sql.Tables.Table
abstract IContext	Context `[get]`

abstract TableInfo	TableInfo `[get]`

bool	IsLocked `[get, private set]`

object ILockable.	RefId `[get]`

int IQueryTable.	ColumnCount `[get]`

virtual int	ColumnCount `[get]`

abstract int	RowCount `[get]`

ObjectName	FullName `[get]`

DbObjectType IDbObject.	ObjectType `[get]`

Properties inherited from Deveel.Data.Sql.Tables.IQueryTable
int	ColumnCount `[get]`

Properties inherited from Deveel.Data.Sql.Tables.ITable
IContext	Context `[get]`

TableInfo	TableInfo `[get]`
	Gets the metadata information of the table, used to resolve the column sources. More...

int	RowCount `[get]`
	Gets the total number of rows in the table. More...

Properties inherited from Deveel.Data.Sql.IDbObject
ObjectName	FullName `[get]`
	Gets the fully qualified name of the object used to resolve it uniquely within the database. More...

DbObjectType	ObjectType `[get]`
	Gets the type of database object that the implementation is for More...

Properties inherited from Deveel.Data.Transactions.ILockable
object	RefId `[get]`

Private Member Functions
ITableCellCache	TableCellCache ()

DataObject	CalcValue (int row, int column, ITableCellCache cache)

int	GetRowGroup (int rowIndex)

int	GetGroupSize (int groupNumber)

IList< int >	GetGroupRows (int groupNumber)

IList< int >	GetTopRowsFromEachGroup ()

IList< int >	GetMaxFromEachGroup (int colNum)

Static Private Member Functions
static void	PlaceAt (IList< int > list, int index, int value)

Private Attributes
readonly IRequest	context

readonly ITableVariableResolver	varResolver

readonly TableInfo	funTableInfo

bool	wholeTableIsSimpleEnum

readonly int	uniqueId

readonly byte[]	expInfo

readonly SqlExpression[]	expList

readonly int	rowCount

IList< int >	groupLinks

IList< int >	groupLookup

TableGroupResolver	groupResolver

bool	wholeTableAsGroup

IList< int >	wholeTableGroup

int	wholeTableGroupSize

Static Private Attributes
static readonly ObjectName	FunctionTableName = new ObjectName(null, "FUNCTIONTABLE")

static int	uniqueKeySeq = 0

Additional Inherited Members
Protected Member Functions inherited from Deveel.Data.Sql.Tables.BaseDataTable
	BaseDataTable ()

	BaseDataTable (IContext context)

override ObjectName	GetResolvedColumnName (int column)

override int	IndexOfColumn (ObjectName columnName)

virtual ColumnIndex	GetColumnIndex (int columnOffset)

override ColumnIndex	GetIndex (int column, int originalColumn, ITable table)

void	SetupIndexes (string indexTypeName)

virtual void	SetupIndexes (Type indexType)

override RawTableInfo	GetRawTableInfo (RawTableInfo rootInfo)

override IEnumerable< int >	ResolveRows (int column, IEnumerable< int > rowSet, ITable ancestor)

Protected Member Functions inherited from Deveel.Data.Sql.Tables.RootTable
virtual bool	IsSameTable (RootTable other)

Protected Member Functions inherited from Deveel.Data.Sql.Tables.Table
virtual void	Dispose (bool disposing)

virtual void	OnLockAcquired (Lock @lock)

virtual void	OnLockReleased (Lock @lock)

int	FindColumn (ObjectName columnName)

Detailed Description

Definition at line 27 of file FunctionTable.cs.

Constructor & Destructor Documentation

Deveel.Data.Sql.Tables.FunctionTable.FunctionTable	(	SqlExpression[]	functionList,
		string[]	columnNames,
		IRequest	queryContext
	)

inline

Definition at line 48 of file FunctionTable.cs.

49 : this(queryContext.Query.Session.Transaction.Database.SingleRowTable, functionList, columnNames, queryContext) {

50 }

Deveel.Data.Sql.Tables.FunctionTable.FunctionTable	(	ITable	table,
		SqlExpression[]	functionList,
		string[]	columnNames,
		IRequest	queryContext
	)

inline

Definition at line 52 of file FunctionTable.cs.

             : base(queryContext.Context) {
             // Make sure we are synchronized over the class.
             lock (typeof(FunctionTable)) {
                 uniqueId = uniqueKeySeq;
                 ++uniqueKeySeq;
             }
 
             uniqueId = (uniqueId & 0x0FFFFFFF) | 0x010000000;
 
             context = queryContext;
 
             ReferenceTable = table;
             varResolver = table.GetVariableResolver();
             varResolver = varResolver.ForRow(0);
 
             // Create a DataTableInfo object for this function table.
             funTableInfo = new TableInfo(FunctionTableName);
 
             expList = new SqlExpression[functionList.Length];
             expInfo = new byte[functionList.Length];
 
             // Create a new DataColumnInfo for each expression, and work out if the
             // expression is simple or not.
             for (int i = 0; i < functionList.Length; ++i) {
                 var expr = functionList[i];
                 // Examine the expression and determine if it is simple or not
                 if (expr.IsConstant() && !expr.HasAggregate(context)) {
                     // If expression is a constant, solve it
                     var result = expr.Evaluate(context, null);
                     if (result.ExpressionType != SqlExpressionType.Constant)
                         throw new InvalidOperationException();
 
                     expr = result;
                     expList[i] = expr;
                     expInfo[i] = 1;
                 } else {
                     // Otherwise must be dynamic
                     expList[i] = expr;
                     expInfo[i] = 0;
                 }
 
                 // Make the column info
                 funTableInfo.AddColumn(columnNames[i], expr.ReturnType(context, varResolver));
             }
 
             // Make sure the table info isn't changed from this point on.
             funTableInfo = funTableInfo.AsReadOnly();
 
             // routine tables are the size of the referring table.
             rowCount = table.RowCount;
 
             // Set schemes to 'blind search'.
             SetupIndexes(DefaultIndexTypes.BlindSearch);
         }

Member Function Documentation

FunctionTable Deveel.Data.Sql.Tables.FunctionTable.AsGroup ( )

inline

Definition at line 311 of file FunctionTable.cs.

                                        {
             // TODO: create a new table ...
             wholeTableAsGroup = true;
 
             wholeTableGroupSize = ReferenceTable.RowCount;
 
             // Set up 'whole_table_group' to the list of all rows in the reference
             // table.
             var en = ReferenceTable.GetEnumerator();
             wholeTableIsSimpleEnum = en is SimpleRowEnumerator;
             if (!wholeTableIsSimpleEnum) {
                 wholeTableGroup = new List<int>(ReferenceTable.RowCount);
                 while (en.MoveNext()) {
                     wholeTableGroup.Add(en.Current.RowId.RowNumber);
                 }
             }
 
             // Set up a group resolver for this method.
             groupResolver = new TableGroupResolver(this);
             return this;
         }

DataObject Deveel.Data.Sql.Tables.FunctionTable.CalcValue	(	int	row,
		int	column,
		ITableCellCache	cache
	)

inlineprivate

Definition at line 165 of file FunctionTable.cs.

                                                                                  {
             var resolver = varResolver.ForRow(row);
 
             if (groupResolver != null) {
                 groupResolver.SetUpGroupForRow(row);
             }
 
             var expr = expList[column];
             var exp = expr.Evaluate(context, resolver, groupResolver);
             if (exp.ExpressionType != SqlExpressionType.Constant)
                 throw new ArgumentException();
 
             var value = ((SqlConstantExpression) exp).Value;
             if (cache != null)
                 cache.Set(context.Query.Session.Transaction.Database.Name, uniqueId, row, column, value);
 
             return value;
         }

FunctionTable Deveel.Data.Sql.Tables.FunctionTable.CreateGroupMatrix ( ObjectName[] columns )

inline

Definition at line 333 of file FunctionTable.cs.

                                                                      {
             // If we have zero rows, then don't bother creating the matrix.
             if (RowCount <= 0 || columns.Length <= 0)
                 return this;
 
             var rootTable = ReferenceTable;
             int rowCount = rootTable.RowCount;
             int[] colLookup = new int[columns.Length];
             for (int i = columns.Length - 1; i >= 0; --i) {
                 colLookup[i] = rootTable.IndexOfColumn(columns[i]);
             }
 
             var rowList = rootTable.OrderRowsByColumns(colLookup).ToList();
 
             // 'row_list' now contains rows in this table sorted by the columns to
             // group by.
 
             // This algorithm will generate two lists.  The group_lookup list maps
             // from rows in this table to the group number the row belongs in.  The
             // group number can be used as an index to the 'group_links' list that
             // contains consequtive links to each row in the group until -1 is reached
             // indicating the end of the group;
 
             groupLookup = new List<int>(rowCount);
             groupLinks = new List<int>(rowCount);
             int currentGroup = 0;
             int previousRow = -1;
             for (int i = 0; i < rowCount; i++) {
                 var rowIndex = rowList[i];
 
                 if (previousRow != -1) {
                     bool equal = true;
                     // Compare cell in column in this row with previous row.
                     for (int n = 0; n < colLookup.Length && equal; ++n) {
                         var c1 = rootTable.GetValue(rowIndex, colLookup[n]);
                         var c2 = rootTable.GetValue(previousRow, colLookup[n]);
                         equal = (c1.CompareTo(c2) == 0);
                     }
 
                     if (!equal) {
                         // If end of group, set bit 15
                         groupLinks.Add(previousRow | 0x040000000);
                         currentGroup = groupLinks.Count;
                     } else {
                         groupLinks.Add(previousRow);
                     }
                 }
 
                 // groupLookup.Insert(row_index, current_group);
                 PlaceAt(groupLookup, rowIndex, currentGroup);
 
                 previousRow = rowIndex;
             }
 
             // Add the final row.
             groupLinks.Add(previousRow | 0x040000000);
 
             // Set up a group resolver for this method.
             groupResolver = new TableGroupResolver(this);
 
             return this;
         }

override IEnumerator<Row> Deveel.Data.Sql.Tables.FunctionTable.GetEnumerator ( )

inlinevirtual

Implements Deveel.Data.Sql.Tables.Table.

Definition at line 108 of file FunctionTable.cs.

                                                          {
             return new SimpleRowEnumerator(this);
         }

IList<int> Deveel.Data.Sql.Tables.FunctionTable.GetGroupRows ( int groupNumber )

inlineprivate

Definition at line 199 of file FunctionTable.cs.

                                                          {
             var rows = new List<int>();
             var row = groupLinks[groupNumber];
 
             while ((row & 0x040000000) == 0) {
                 rows.Add(row);
                 ++groupNumber;
                 row = groupLinks[groupNumber];
             }
 
             rows.Add(row & 0x03FFFFFFF);
             return rows;
         }

int Deveel.Data.Sql.Tables.FunctionTable.GetGroupSize ( int groupNumber )

inlineprivate

Definition at line 188 of file FunctionTable.cs.

                                                   {
             int groupSize = 1;
             int i = groupLinks[groupNumber];
             while ((i & 0x040000000) == 0) {
                 ++groupSize;
                 ++groupNumber;
                 i = groupLinks[groupNumber];
             }
             return groupSize;
         }

IList<int> Deveel.Data.Sql.Tables.FunctionTable.GetMaxFromEachGroup ( int colNum )

inlineprivate

Definition at line 229 of file FunctionTable.cs.

                                                            {
             var refTab = ReferenceTable;
 
             var extractRows = new List<int>();
             var size = groupLinks.Count;
 
             int toTakeInGroup = -1;
             DataObject max = null;
 
             for (int i = 0; i < size; ++i) {
                 int row = groupLinks[i];
 
                 int actRIndex = row & 0x03FFFFFFF;
                 var cell = refTab.GetValue(actRIndex, colNum);
 
                 if (max == null || cell.CompareTo(max) > 0) {
                     max = cell;
                     toTakeInGroup = actRIndex;
                 }
 
                 if ((row & 0x040000000) != 0) {
                     extractRows.Add(toTakeInGroup);
                     max = null;
                 }
             }
 
             return extractRows;
         }

int Deveel.Data.Sql.Tables.FunctionTable.GetRowGroup ( int rowIndex )

inlineprivate

Definition at line 184 of file FunctionTable.cs.

                                               {
             return groupLookup[rowIndex];
         }

IList<int> Deveel.Data.Sql.Tables.FunctionTable.GetTopRowsFromEachGroup ( )

inlineprivate

Definition at line 213 of file FunctionTable.cs.

                                                      {
             var extractRows = new List<int>();
             var size = groupLinks.Count;
             var take = true;
 
             for (int i = 0; i < size; ++i) {
                 int r = groupLinks[i];
                 if (take)
                     extractRows.Add(r & 0x03FFFFFFF);
 
                 take = (r & 0x040000000) != 0;
             }
 
             return extractRows;
         }

override DataObject Deveel.Data.Sql.Tables.FunctionTable.GetValue	(	long	rowNumber,
		int	columnOffset
	)

inlinevirtual

Gets a single cell within the table that is located at the given column offset and row.

Parameters

rowNumber	The unique number of the row where the cell is located.
columnOffset	The zero-based offset of the column of the cell to return.

Returns: Returns an instance of DataObject that is contained in the cell located by the row and column coordinates provided.

Exceptions

ArgumentOutOfRangeException If the given columnOffset is less than zero or greater or equal than the number of columns defined in the table metadata.

See also: Tables.TableInfo.IndexOfColumn(string)

Implements Deveel.Data.Sql.Tables.Table.

Definition at line 144 of file FunctionTable.cs.

                                                                               {
             // [ FUNCTION TABLE CACHING NOW USES THE GLOBAL CELL CACHING MECHANISM ]
             // Check if in the cache,
             var cache = TableCellCache();
 
             // Is the column worth caching, and is caching enabled?
             if (expInfo[columnOffset] == 0 && cache != null) {
                 DataObject cell;
                 if (cache.TryGetValue(context.Query.Session.Transaction.Database.Name, uniqueId, (int)rowNumber, columnOffset, out cell))
                     // In the cache so return the cell.
                     return cell;
 
                 // Not in the cache so calculate the value and write it in the cache.
                 return CalcValue((int)rowNumber, columnOffset, cache);
             }
 
             // Caching is not enabled
             return CalcValue((int)rowNumber, columnOffset, null);
 
         }

override void Deveel.Data.Sql.Tables.FunctionTable.Lock ( )

inlinevirtual

Implements Deveel.Data.Sql.Tables.Table.

Definition at line 122 of file FunctionTable.cs.

                                     {
             // We Lock the reference table.
             // NOTE: This cause the reference table to Lock twice when we use the
             //  'MergeWithReference' method.  While this isn't perfect behaviour, it
             //  means if 'MergeWithReference' isn't used, we still maintain a safe
             //  level of locking.
             ReferenceTable.Lock();
         }

ITable Deveel.Data.Sql.Tables.FunctionTable.MergeWith ( ObjectName maxColumn )

inline

Definition at line 258 of file FunctionTable.cs.

                                                       {
             var table = ReferenceTable;
 
             IList<int> rowList;
 
             if (wholeTableAsGroup) {
                 // Whole table is group, so take top entry of table.
 
                 rowList = new List<int>(1);
                 var rowEnum = table.GetEnumerator();
                 if (rowEnum.MoveNext()) {
                     rowList.Add(rowEnum.Current.RowId.RowNumber);
                 } else {
                     // MAJOR HACK: If the referencing table has no elements then we choose
                     //   an arbitary index from the reference table to merge so we have
                     //   at least one element in the table.
                     //   This is to fix the 'SELECT COUNT(*) FROM empty_table' bug.
                     rowList.Add(Int32.MaxValue - 1);
                 }
             } else if (table.RowCount == 0) {
                 rowList = new List<int>(0);
             } else if (groupLinks != null) {
                 // If we are grouping, reduce down to only include one row from each
                 // group.
                 if (maxColumn == null) {
                     rowList = GetTopRowsFromEachGroup();
                 } else {
                     var colNum = ReferenceTable.FindColumn(maxColumn);
                     rowList = GetMaxFromEachGroup(colNum);
                 }
             } else {
                 // OPTIMIZATION: This should be optimized.  It should be fairly trivial
                 //   to generate a Table implementation that efficiently merges this
                 //   function table with the reference table.
 
                 // This means there is no grouping, so merge with entire table,
                 int rowCount = table.RowCount;
                 rowList = new List<int>(rowCount);
                 var en = table.GetEnumerator();
                 while (en.MoveNext()) {
                     rowList.Add(en.Current.RowId.RowNumber);
                 }
             }
 
             // Create a virtual table that's the new group table merged with the
             // functions in this...
 
             var tabs = new [] { table, this };
             var rowSets = new[] { rowList, rowList };
 
             return new VirtualTable(tabs, rowSets);
         }

static void Deveel.Data.Sql.Tables.FunctionTable.PlaceAt	(	IList< int >	list,
		int	index,
		int	value
	)

inlinestaticprivate

Definition at line 396 of file FunctionTable.cs.

                                                                            {
             while (index > list.Count) {
                 list.Add(0);
             }
 
             list.Insert(index, value);
         }

override void Deveel.Data.Sql.Tables.FunctionTable.Release ( )

inlinevirtual

Implements Deveel.Data.Sql.Tables.Table.

Definition at line 131 of file FunctionTable.cs.

                                        {
             // We unlock the reference table.
             // NOTE: This cause the reference table to unlock twice when we use the
             //  'MergeWithReference' method.  While this isn't perfect behaviour, it
             //  means if 'MergeWithReference' isn't used, we still maintain a safe
             //  level of locking.
             ReferenceTable.Release();
         }

static ITable Deveel.Data.Sql.Tables.FunctionTable.ResultTable	(	IRequest	context,
		SqlExpression	expression
	)

inlinestatic

Definition at line 404 of file FunctionTable.cs.

                                                                                      {
             var exp = new [] { expression };
             var names = new[] { "result" };
             var table = new FunctionTable(exp, names, context);
 
             return new SubsetColumnTable(table, new[]{0}, new []{new ObjectName("result") });
         }

static ITable Deveel.Data.Sql.Tables.FunctionTable.ResultTable	(	IRequest	context,
		DataObject	value
	)

inlinestatic

Definition at line 412 of file FunctionTable.cs.

                                                                              {
             return ResultTable(context, SqlExpression.Constant(value));
         }

static ITable Deveel.Data.Sql.Tables.FunctionTable.ResultTable	(	IRequest	context,
		int	value
	)

inlinestatic

Definition at line 416 of file FunctionTable.cs.

                                                                       {
             return ResultTable(context, DataObject.Integer(value));
         }

ITableCellCache Deveel.Data.Sql.Tables.FunctionTable.TableCellCache ( )

inlineprivate

Definition at line 140 of file FunctionTable.cs.

                                                  {
             return Context.ResolveService<ITableCellCache>();
         }

Member Data Documentation

readonly IRequest Deveel.Data.Sql.Tables.FunctionTable.context

private

Definition at line 28 of file FunctionTable.cs.

readonly byte [] Deveel.Data.Sql.Tables.FunctionTable.expInfo

private

Definition at line 33 of file FunctionTable.cs.

readonly SqlExpression [] Deveel.Data.Sql.Tables.FunctionTable.expList

private

Definition at line 34 of file FunctionTable.cs.

readonly ObjectName Deveel.Data.Sql.Tables.FunctionTable.FunctionTableName = new ObjectName(null, "FUNCTIONTABLE")

staticprivate

Definition at line 44 of file FunctionTable.cs.

readonly TableInfo Deveel.Data.Sql.Tables.FunctionTable.funTableInfo

private

Definition at line 30 of file FunctionTable.cs.

IList<int> Deveel.Data.Sql.Tables.FunctionTable.groupLinks

private

Definition at line 37 of file FunctionTable.cs.

IList<int> Deveel.Data.Sql.Tables.FunctionTable.groupLookup

private

Definition at line 38 of file FunctionTable.cs.

TableGroupResolver Deveel.Data.Sql.Tables.FunctionTable.groupResolver

private

Definition at line 39 of file FunctionTable.cs.

readonly int Deveel.Data.Sql.Tables.FunctionTable.rowCount

private

Definition at line 35 of file FunctionTable.cs.

readonly int Deveel.Data.Sql.Tables.FunctionTable.uniqueId

private

Definition at line 32 of file FunctionTable.cs.

int Deveel.Data.Sql.Tables.FunctionTable.uniqueKeySeq = 0

staticprivate

Definition at line 46 of file FunctionTable.cs.

readonly ITableVariableResolver Deveel.Data.Sql.Tables.FunctionTable.varResolver

private

Definition at line 29 of file FunctionTable.cs.

bool Deveel.Data.Sql.Tables.FunctionTable.wholeTableAsGroup

private

Definition at line 40 of file FunctionTable.cs.

IList<int> Deveel.Data.Sql.Tables.FunctionTable.wholeTableGroup

private

Definition at line 41 of file FunctionTable.cs.

int Deveel.Data.Sql.Tables.FunctionTable.wholeTableGroupSize

private

Definition at line 42 of file FunctionTable.cs.

bool Deveel.Data.Sql.Tables.FunctionTable.wholeTableIsSimpleEnum

private

Definition at line 31 of file FunctionTable.cs.

Property Documentation

ITable Deveel.Data.Sql.Tables.FunctionTable.ReferenceTable

getprivate set

Definition at line 112 of file FunctionTable.cs.

override int Deveel.Data.Sql.Tables.FunctionTable.RowCount

get

Definition at line 118 of file FunctionTable.cs.

override TableInfo Deveel.Data.Sql.Tables.FunctionTable.TableInfo

get

Definition at line 114 of file FunctionTable.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/FunctionTable.cs

Classes

Public Member Functions

Static Public Member Functions

Properties

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation