Static Public Member Functions
static int	DeleteFrom (this IQuery context, ObjectName tableName, SqlQueryExpression query)

static int	DeleteFrom (this IQuery context, ObjectName tableName, SqlExpression expression)

static int	DeleteFrom (this IQuery context, ObjectName tableName, SqlExpression expression, int limit)

static int	DeleteFrom (this IQuery context, ObjectName tableName, SqlQueryExpression query, int limit)

static int	DeleteFrom (this IQuery context, ObjectName tableName, ITable deleteSet, int limit)

static int	UpdateTable (this IQuery context, ObjectName tableName, IQueryPlanNode queryPlan, IEnumerable< SqlAssignExpression > assignments, int limit)

static void	InsertIntoTable (this IQuery context, ObjectName tableName, IEnumerable< SqlAssignExpression > assignments)

static int	InsertIntoTable (this IQuery context, ObjectName tableName, IEnumerable< SqlAssignExpression[]> assignments)

static ObjectName	ResolveTableName (this IQuery query, ObjectName tableName)

static ObjectName	ResolveTableName (this IQuery query, string name)

static bool	TableExists (this IQuery query, ObjectName tableName)

static void	CreateTable (this IQuery query, TableInfo tableInfo)

static void	CreateTable (this IQuery query, TableInfo tableInfo, bool onlyIfNotExists)

static void	CreateTable (this IQuery query, TableInfo tableInfo, bool onlyIfNotExists, bool temporary)

static ITableQueryInfo	GetTableQueryInfo (this IQuery context, ObjectName tableName, ObjectName alias)

static void	DropTables (this IQuery query, IEnumerable< ObjectName > tableNames)

static void	DropTables (this IQuery query, IEnumerable< ObjectName > tableNames, bool onlyIfExists)

static void	DropTable (this IQuery query, ObjectName tableName)

static void	DropTable (this IQuery query, ObjectName tableName, bool onlyIfExists)

static void	AlterTable (this IQuery query, TableInfo tableInfo)

static ITable	GetTable (this IQuery query, ObjectName tableName)

static IMutableTable	GetMutableTable (this IQuery query, ObjectName tableName)

static ITable	GetCachedTable (this IQuery query, string cacheKey)

static void	CacheTable (this IQuery query, string cacheKey, ITable table)

static void	ClearCachedTables (this IQuery query)

static void	AddPrimaryKey (this IQuery query, ObjectName tableName, string[] columnNames)

static void	AddPrimaryKey (this IQuery query, ObjectName tableName, string[] columnNames, string constraintName)

static void	AddPrimaryKey (this IQuery query, ObjectName tableName, string columnName)

static void	AddPrimaryKey (this IQuery query, ObjectName tableName, string columnName, string constraintName)

static void	AddForeignKey (this IQuery query, ObjectName table, string[] columns, ObjectName refTable, string[] refColumns, ForeignKeyAction deleteRule, ForeignKeyAction updateRule, String constraintName)

static void	AddForeignKey (this IQuery query, ObjectName table, string[] columns, ObjectName refTable, string[] refColumns, ForeignKeyAction deleteRule, ForeignKeyAction updateRule, ConstraintDeferrability deferred, String constraintName)

static void	AddUniqueKey (this IQuery query, ObjectName tableName, string[] columns)

static void	AddUniqueKey (this IQuery query, ObjectName tableName, string[] columns, string constraintName)

static void	AddUniqueKey (this IQuery query, ObjectName tableName, string[] columns, ConstraintDeferrability deferrability)

static void	AddUniqueKey (this IQuery query, ObjectName tableName, string[] columns, ConstraintDeferrability deferrability, string constraintName)

static void	AddCheck (this IQuery query, ObjectName tableName, SqlExpression expression, string constraintName)

static void	AddCheck (this IQuery query, ObjectName tableName, SqlExpression expression, ConstraintDeferrability deferred, string constraintName)

static void	DropAllTableConstraints (this IQuery query, ObjectName tableName)

static int	DropConstraint (this IQuery query, ObjectName tableName, string constraintName)

static void	AddConstraint (this IQuery query, ObjectName tableName, ConstraintInfo constraintInfo)

static bool	DropPrimaryKey (this IQuery query, ObjectName tableName, string constraintName)

static void	CheckConstraints (this IQuery query, ObjectName tableName)

static ConstraintInfo[]	GetTableCheckExpressions (this IQuery query, ObjectName tableName)

static ConstraintInfo[]	GetTableImportedForeignKeys (this IQuery query, ObjectName tableName)

static ConstraintInfo[]	GetTableForeignKeys (this IQuery query, ObjectName tableName)

static ConstraintInfo	GetTablePrimaryKey (this IQuery query, ObjectName tableName)

static ConstraintInfo[]	GetTableUniqueKeys (this IQuery query, ObjectName tableName)

Static Package Functions
static void	CreateSystemTable (this IQuery query, TableInfo tableInfo)

Static Private Member Functions
static ICache	TableCache (this IQuery query)

Detailed Description

Definition at line 28 of file QueryExtensions.Commands.cs.

Member Function Documentation

static void Deveel.Data.Sql.Tables.QueryExtensions.AddCheck	(	this IQuery	query,
		ObjectName	tableName,
		SqlExpression	expression,
		string	constraintName
	)

inlinestatic

Definition at line 276 of file QueryExtensions.cs.

                                                                                                                               {
             AddCheck(query, tableName, expression, ConstraintDeferrability.InitiallyImmediate, constraintName);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.AddCheck	(	this IQuery	query,
		ObjectName	tableName,
		SqlExpression	expression,
		ConstraintDeferrability	deferred,
		string	constraintName
	)

inlinestatic

Definition at line 280 of file QueryExtensions.cs.

                                                                                                                                                                 {
             query.Session.AddCheck(tableName, expression, deferred, constraintName);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.AddConstraint	(	this IQuery	query,
		ObjectName	tableName,
		ConstraintInfo	constraintInfo
	)

inlinestatic

Definition at line 292 of file QueryExtensions.cs.

                                                                                                                  {
             if (constraintInfo.ConstraintType == ConstraintType.PrimaryKey) {
                 var columnNames = constraintInfo.ColumnNames;
                 if (columnNames.Length > 1)
                     throw new ArgumentException();
 
                 query.AddPrimaryKey(tableName, columnNames[0], constraintInfo.ConstraintName);
             } else if (constraintInfo.ConstraintType == ConstraintType.Unique) {
                 query.AddUniqueKey(tableName, constraintInfo.ColumnNames, constraintInfo.ConstraintName);
             } else if (constraintInfo.ConstraintType == ConstraintType.Check) {
                 query.AddCheck(tableName, constraintInfo.CheckExpression, constraintInfo.ConstraintName);
             } else if (constraintInfo.ConstraintType == ConstraintType.ForeignKey) {
                 query.AddForeignKey(tableName, constraintInfo.ColumnNames, constraintInfo.ForeignTable,
                     constraintInfo.ForeignColumnNames, constraintInfo.OnDelete, constraintInfo.OnUpdate, constraintInfo.ConstraintName);
             }
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.AddForeignKey	(	this IQuery	query,
		ObjectName	table,
		string[]	columns,
		ObjectName	refTable,
		string[]	refColumns,
		ForeignKeyAction	deleteRule,
		ForeignKeyAction	updateRule,
		String	constraintName
	)

inlinestatic

Definition at line 238 of file QueryExtensions.cs.

                                    {
             AddForeignKey(query, table, columns, refTable, refColumns, deleteRule, updateRule, ConstraintDeferrability.InitiallyImmediate, constraintName);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.AddForeignKey	(	this IQuery	query,
		ObjectName	table,
		string[]	columns,
		ObjectName	refTable,
		string[]	refColumns,
		ForeignKeyAction	deleteRule,
		ForeignKeyAction	updateRule,
		ConstraintDeferrability	deferred,
		String	constraintName
	)

inlinestatic

Definition at line 244 of file QueryExtensions.cs.

                                    {
             if (!query.UserCanAlterTable(table))
                 throw new MissingPrivilegesException(query.UserName(), table, Privileges.Alter);
             if (!query.UserCanReferenceTable(refTable))
                 throw new MissingPrivilegesException(query.UserName(), refTable, Privileges.References);
 
             query.Session.AddForeignKey(table, columns, refTable, refColumns, deleteRule, updateRule, deferred, constraintName);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.AddPrimaryKey	(	this IQuery	query,
		ObjectName	tableName,
		string[]	columnNames
	)

inlinestatic

Definition at line 219 of file QueryExtensions.cs.

                                                                                                         {
             AddPrimaryKey(query, tableName, columnNames, null);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.AddPrimaryKey	(	this IQuery	query,
		ObjectName	tableName,
		string[]	columnNames,
		string	constraintName
	)

inlinestatic

Definition at line 223 of file QueryExtensions.cs.

                                                                                                                                {
             if (!query.UserCanAlterTable(tableName))
                 throw new MissingPrivilegesException(query.UserName(), tableName, Privileges.Alter);
 
             query.Session.AddPrimaryKey(tableName, columnNames, ConstraintDeferrability.InitiallyImmediate, constraintName);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.AddPrimaryKey	(	this IQuery	query,
		ObjectName	tableName,
		string	columnName
	)

inlinestatic

Definition at line 230 of file QueryExtensions.cs.

                                                                                                      {
             AddPrimaryKey(query, tableName, columnName, null);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.AddPrimaryKey	(	this IQuery	query,
		ObjectName	tableName,
		string	columnName,
		string	constraintName
	)

inlinestatic

Definition at line 234 of file QueryExtensions.cs.

                                                                                                                             {
             query.AddPrimaryKey(tableName, new[] { columnName }, constraintName);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.AddUniqueKey	(	this IQuery	query,
		ObjectName	tableName,
		string[]	columns
	)

inlinestatic

Definition at line 255 of file QueryExtensions.cs.

                                                                                                    {
             AddUniqueKey(query, tableName, columns, null);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.AddUniqueKey	(	this IQuery	query,
		ObjectName	tableName,
		string[]	columns,
		string	constraintName
	)

inlinestatic

Definition at line 259 of file QueryExtensions.cs.

                                                                                                                           {
             AddUniqueKey(query, tableName, columns, ConstraintDeferrability.InitiallyImmediate, constraintName);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.AddUniqueKey	(	this IQuery	query,
		ObjectName	tableName,
		string[]	columns,
		ConstraintDeferrability	deferrability
	)

inlinestatic

Definition at line 263 of file QueryExtensions.cs.

                                                    {
             AddUniqueKey(query, tableName, columns, deferrability, null);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.AddUniqueKey	(	this IQuery	query,
		ObjectName	tableName,
		string[]	columns,
		ConstraintDeferrability	deferrability,
		string	constraintName
	)

inlinestatic

Definition at line 268 of file QueryExtensions.cs.

                                                                           {
             if (!query.UserCanAlterTable(tableName))
                 throw new MissingPrivilegesException(query.UserName(), tableName, Privileges.Alter);
 
             query.Session.AddUniqueKey(tableName, columns, deferrability, constraintName);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.AlterTable	(	this IQuery	query,
		TableInfo	tableInfo
	)

inlinestatic

Definition at line 164 of file QueryExtensions.cs.

                                                                               {
             query.AlterObject(tableInfo);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.CacheTable	(	this IQuery	query,
		string	cacheKey,
		ITable	table
	)

inlinestatic

Definition at line 201 of file QueryExtensions.cs.

                                                                                         {
             var tableCache = query.TableCache();
             if (tableCache == null)
                 return;
 
             tableCache.Set(cacheKey, table);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.CheckConstraints	(	this IQuery	query,
		ObjectName	tableName
	)

inlinestatic

Definition at line 313 of file QueryExtensions.cs.

                                                                                      {
             query.Session.CheckConstraintViolations(tableName);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.ClearCachedTables ( this IQuery query )

inlinestatic

Definition at line 209 of file QueryExtensions.cs.

                                                                 {
             var tableCache = query.TableCache();
             if (tableCache == null)
                 return;
 
             tableCache.Clear();
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.CreateSystemTable	(	this IQuery	query,
		TableInfo	tableInfo
	)

inlinestaticpackage

Definition at line 91 of file QueryExtensions.cs.

                                                                                        {
             if (tableInfo == null)
                 throw new ArgumentNullException("tableInfo");
 
             var tableName = tableInfo.TableName;
 
             if (!query.UserCanCreateTable(tableName))
                 throw new MissingPrivilegesException(query.User().Name, tableName, Privileges.Create);
 
             query.Session.CreateTable(tableInfo, false);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.CreateTable	(	this IQuery	query,
		TableInfo	tableInfo
	)

inlinestatic

Definition at line 55 of file QueryExtensions.cs.

                                                                                {
             CreateTable(query, tableInfo, false);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.CreateTable	(	this IQuery	query,
		TableInfo	tableInfo,
		bool	onlyIfNotExists
	)

inlinestatic

Definition at line 59 of file QueryExtensions.cs.

                                                                                                      {
             CreateTable(query, tableInfo, onlyIfNotExists, false);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.CreateTable	(	this IQuery	query,
		TableInfo	tableInfo,
		bool	onlyIfNotExists,
		bool	temporary
	)

inlinestatic

Definition at line 63 of file QueryExtensions.cs.

                                                                                                                      {
             if (tableInfo == null)
                 throw new ArgumentNullException("tableInfo");
 
             var tableName = tableInfo.TableName;
 
             if (!query.UserCanCreateTable(tableName))
                 throw new MissingPrivilegesException(query.User().Name, tableName, Privileges.Create);
 
             if (query.TableExists(tableName)) {
                 if (!onlyIfNotExists)
                     throw new InvalidOperationException(
                         String.Format("The table {0} already exists and the IF NOT EXISTS clause was not specified.", tableName));
 
                 return;
             }
 
             query.Session.CreateTable(tableInfo, temporary);
 
             using (var systemContext = query.Direct()) {
                 systemContext.GrantToUserOnTable(tableInfo.TableName, query.User().Name, Privileges.TableAll);
             }
         }

static int Deveel.Data.Sql.Tables.QueryExtensions.DeleteFrom	(	this IQuery	context,
		ObjectName	tableName,
		SqlQueryExpression	query
	)

inlinestatic

Definition at line 29 of file QueryExtensions.Commands.cs.

                                                                                                           {
             return DeleteFrom(context, tableName, query, -1);
         }

static int Deveel.Data.Sql.Tables.QueryExtensions.DeleteFrom	(	this IQuery	context,
		ObjectName	tableName,
		SqlExpression	expression
	)

inlinestatic

Definition at line 33 of file QueryExtensions.Commands.cs.

                                                                                                           {
             return DeleteFrom(context, tableName, expression, -1);
         }

static int Deveel.Data.Sql.Tables.QueryExtensions.DeleteFrom	(	this IQuery	context,
		ObjectName	tableName,
		SqlExpression	expression,
		int	limit
	)

inlinestatic

Definition at line 37 of file QueryExtensions.Commands.cs.

                                                                                                                      {
             if (expression is SqlQueryExpression)
                 return context.DeleteFrom(tableName, (SqlQueryExpression)expression, limit);
 
             var table = context.GetMutableTable(tableName);
             if (table == null)
                 throw new ObjectNotFoundException(tableName);
 
             var queryExpression = new SqlQueryExpression(new List<SelectColumn> { SelectColumn.Glob("*") });
             queryExpression.FromClause.AddTable(tableName.Name);
             queryExpression.WhereExpression = expression;
 
             var planExpression = queryExpression.Evaluate(context, null);
             var plan = (SqlQueryObject)((SqlConstantExpression)planExpression).Value.Value;
             var deleteSet = plan.QueryPlan.Evaluate(context);
 
             return context.DeleteFrom(tableName, deleteSet, limit);
         }

static int Deveel.Data.Sql.Tables.QueryExtensions.DeleteFrom	(	this IQuery	context,
		ObjectName	tableName,
		SqlQueryExpression	query,
		int	limit
	)

inlinestatic

Definition at line 56 of file QueryExtensions.Commands.cs.

                                                                                                                      {
             IQueryPlanNode plan;
 
             try {
                 var planValue = query.EvaluateToConstant(context, null);
                 if (planValue == null)
                     throw new InvalidOperationException();
 
                 if (!(planValue.Type is QueryType))
                     throw new InvalidOperationException();
 
                 plan = ((SqlQueryObject)planValue.Value).QueryPlan;
             } catch (QueryException) {
                 throw;
             } catch (SecurityException) {
                 throw;
             } catch (Exception ex) {
                 throw new InvalidOperationException(String.Format("Could not delete from table '{0}': unable to form the delete set.", tableName), ex);
             }
 
             var deleteSet = plan.Evaluate(context);
             return context.DeleteFrom(tableName, deleteSet, limit);
         }

static int Deveel.Data.Sql.Tables.QueryExtensions.DeleteFrom	(	this IQuery	context,
		ObjectName	tableName,
		ITable	deleteSet,
		int	limit
	)

inlinestatic

Definition at line 80 of file QueryExtensions.Commands.cs.

                                                                                                              {
             if (!context.UserCanDeleteFromTable(tableName))
                 throw new MissingPrivilegesException(context.UserName(), tableName, Privileges.Delete);
 
             var table = context.GetMutableTable(tableName);
             if (table == null)
                 throw new ObjectNotFoundException(tableName);
 
             return table.Delete(deleteSet, limit);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.DropAllTableConstraints	(	this IQuery	query,
		ObjectName	tableName
	)

inlinestatic

Definition at line 284 of file QueryExtensions.cs.

                                                                                             {
             query.Session.DropAllTableConstraints(tableName);
         }

static int Deveel.Data.Sql.Tables.QueryExtensions.DropConstraint	(	this IQuery	query,
		ObjectName	tableName,
		string	constraintName
	)

inlinestatic

Definition at line 288 of file QueryExtensions.cs.

                                                                                                          {
             return query.Session.DropTableConstraint(tableName, constraintName);
         }

static bool Deveel.Data.Sql.Tables.QueryExtensions.DropPrimaryKey	(	this IQuery	query,
		ObjectName	tableName,
		string	constraintName
	)

inlinestatic

Definition at line 309 of file QueryExtensions.cs.

                                                                                                           {
             return query.Session.DropTablePrimaryKey(tableName, constraintName);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.DropTable	(	this IQuery	query,
		ObjectName	tableName
	)

inlinestatic

Definition at line 156 of file QueryExtensions.cs.

                                                                               {
             DropTable(query, tableName, false);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.DropTable	(	this IQuery	query,
		ObjectName	tableName,
		bool	onlyIfExists
	)

inlinestatic

Definition at line 160 of file QueryExtensions.cs.

                                                                                                  {
             query.DropTables(new[] { tableName }, onlyIfExists);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.DropTables	(	this IQuery	query,
		IEnumerable< ObjectName >	tableNames
	)

inlinestatic

Definition at line 103 of file QueryExtensions.cs.

                                                                                              {
             DropTables(query, tableNames, false);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.DropTables	(	this IQuery	query,
		IEnumerable< ObjectName >	tableNames,
		bool	onlyIfExists
	)

inlinestatic

Definition at line 107 of file QueryExtensions.cs.

                                                                                                                 {
             var tableNameList = tableNames.ToList();
             foreach (var tableName in tableNameList) {
                 if (!query.UserCanDropObject(DbObjectType.Table, tableName))
                     throw new MissingPrivilegesException(query.UserName(), tableName, Privileges.Drop);
             }
 
             // Check there are no referential links to any tables being dropped
             foreach (var tableName in tableNameList) {
                 var refs = query.GetTableImportedForeignKeys(tableName);
 
                 foreach (var reference in refs) {
                     // If the key table isn't being dropped then error
                     if (!tableNameList.Contains(reference.TableName)) {
                         throw new ConstraintViolationException(SqlModelErrorCodes.DropTableViolation,
                             String.Format("Constraint violation ({0}) dropping table '{1}' because of referential link from '{2}'",
                                 reference.ConstraintName, tableName, reference.TableName));
                     }
                 }
             }
 
             // If the 'only if exists' flag is false, we need to check tables to drop
             // exist first.
             if (!onlyIfExists) {
                 // For each table to drop.
                 foreach (var tableName in tableNameList) {
                     // If table doesn't exist, throw an error
                     if (!query.TableExists(tableName)) {
                         throw new InvalidOperationException(String.Format("The table '{0}' does not exist and cannot be dropped.",
                             tableName));
                     }
                 }
             }
 
             foreach (var tname in tableNameList) {
                 // Does the table already exist?
                 if (query.TableExists(tname)) {
                     // Drop table in the transaction
                     query.DropObject(DbObjectType.Table, tname);
 
                     // Revoke all the grants on the table
                     query.RevokeAllGrantsOnTable(tname);
 
                     // Drop all constraints from the schema
                     query.DropAllTableConstraints(tname);
                 }
             }
         }

static ITable Deveel.Data.Sql.Tables.QueryExtensions.GetCachedTable	(	this IQuery	query,
		string	cacheKey
	)

inlinestatic

Definition at line 189 of file QueryExtensions.cs.

                                                                                 {
             var tableCache = query.TableCache();
             if (tableCache == null)
                 return null;
 
             object obj;
             if (!tableCache.TryGet(cacheKey, out obj))
                 return null;
 
             return obj as ITable;
         }

static IMutableTable Deveel.Data.Sql.Tables.QueryExtensions.GetMutableTable	(	this IQuery	query,
		ObjectName	tableName
	)

inlinestatic

Definition at line 185 of file QueryExtensions.cs.

                                                                                              {
             return query.GetTable(tableName) as IMutableTable;
         }

static ITable Deveel.Data.Sql.Tables.QueryExtensions.GetTable	(	this IQuery	query,
		ObjectName	tableName
	)

inlinestatic

Definition at line 172 of file QueryExtensions.cs.

                                                                                {
             var table = query.GetCachedTable(tableName.FullName) as ITable;
             if (table == null) {
                 table = query.Session.GetTable(tableName);
                 if (table != null) {
                     table = new UserContextTable(query, table);
                     query.CacheTable(tableName.FullName, table);
                 }
             }
 
             return table;
         }

static ConstraintInfo [] Deveel.Data.Sql.Tables.QueryExtensions.GetTableCheckExpressions	(	this IQuery	query,
		ObjectName	tableName
	)

inlinestatic

Definition at line 317 of file QueryExtensions.cs.

                                                                                                          {
             return query.Session.QueryTableCheckExpressions(tableName);
         }

static ConstraintInfo [] Deveel.Data.Sql.Tables.QueryExtensions.GetTableForeignKeys	(	this IQuery	query,
		ObjectName	tableName
	)

inlinestatic

Definition at line 325 of file QueryExtensions.cs.

                                                                                                     {
             return query.Session.QueryTableForeignKeys(tableName);
         }

static ConstraintInfo [] Deveel.Data.Sql.Tables.QueryExtensions.GetTableImportedForeignKeys	(	this IQuery	query,
		ObjectName	tableName
	)

inlinestatic

Definition at line 321 of file QueryExtensions.cs.

                                                                                                             {
             return query.Session.QueryTableImportedForeignKeys(tableName);
         }

static ConstraintInfo Deveel.Data.Sql.Tables.QueryExtensions.GetTablePrimaryKey	(	this IQuery	query,
		ObjectName	tableName
	)

inlinestatic

Definition at line 329 of file QueryExtensions.cs.

                                                                                                  {
             return query.Session.QueryTablePrimaryKey(tableName);
         }

static ITableQueryInfo Deveel.Data.Sql.Tables.QueryExtensions.GetTableQueryInfo	(	this IQuery	context,
		ObjectName	tableName,
		ObjectName	alias
	)

inlinestatic

Definition at line 87 of file QueryExtensions.cs.

                                                                                                                      {
             return context.Session.GetTableQueryInfo(tableName, alias);
         }

static ConstraintInfo [] Deveel.Data.Sql.Tables.QueryExtensions.GetTableUniqueKeys	(	this IQuery	query,
		ObjectName	tableName
	)

inlinestatic

Definition at line 333 of file QueryExtensions.cs.

                                                                                                    {
             return query.Session.QueryTableUniqueKeys(tableName);
         }

static void Deveel.Data.Sql.Tables.QueryExtensions.InsertIntoTable	(	this IQuery	context,
		ObjectName	tableName,
		IEnumerable< SqlAssignExpression >	assignments
	)

inlinestatic

Definition at line 111 of file QueryExtensions.Commands.cs.

                                                                                                                                     {
             var columnNames =
                 assignments.Select(x => x.ReferenceExpression)
                     .Cast<SqlReferenceExpression>()
                     .Select(x => x.ReferenceName.Name).ToArray();
             if (!context.UserCanInsertIntoTable(tableName, columnNames))
                 throw new MissingPrivilegesException(context.UserName(), tableName, Privileges.Insert);
 
             var table = context.GetMutableTable(tableName);
             if (table == null)
                 throw new ObjectNotFoundException(tableName);
 
             var row = table.NewRow();
             foreach (var expression in assignments) {
                 row.EvaluateAssignment(expression, context);
             }
 
             table.AddRow(row);
         }

static int Deveel.Data.Sql.Tables.QueryExtensions.InsertIntoTable	(	this IQuery	context,
		ObjectName	tableName,
		IEnumerable< SqlAssignExpression[]>	assignments
	)

inlinestatic

Definition at line 131 of file QueryExtensions.Commands.cs.

                                                                                                                                      {
             int insertCount = 0;
 
             foreach (var assignment in assignments) {
                 context.InsertIntoTable(tableName, assignment);
                 insertCount++;
             }
 
             return insertCount;
         }

static ObjectName Deveel.Data.Sql.Tables.QueryExtensions.ResolveTableName	(	this IQuery	query,
		ObjectName	tableName
	)

inlinestatic

Definition at line 30 of file QueryExtensions.cs.

                                                                                            {
             return query.Session.ResolveTableName(tableName);
         }

static ObjectName Deveel.Data.Sql.Tables.QueryExtensions.ResolveTableName	(	this IQuery	query,
		string	name
	)

inlinestatic

Definition at line 34 of file QueryExtensions.cs.

                                                                                   {
             var schema = query.CurrentSchema();
             if (String.IsNullOrEmpty(schema))
                 throw new InvalidOperationException("Default schema not specified in the query.");
 
             var objSchemaName = query.ResolveSchemaName(schema);
             if (objSchemaName == null)
                 throw new InvalidOperationException(
                     String.Format("The default schema of the session '{0}' is not defined in the database.", schema));
 
             var objName = ObjectName.Parse(name);
             if (objName.Parent == null)
                 objName = new ObjectName(objSchemaName, objName.Name);
 
             return query.ResolveTableName(objName);
         }

static ICache Deveel.Data.Sql.Tables.QueryExtensions.TableCache ( this IQuery query )

inlinestaticprivate

Definition at line 168 of file QueryExtensions.cs.

                                                             {
             return query.Context.ResolveService<ICache>("TableCache");
         }

static bool Deveel.Data.Sql.Tables.QueryExtensions.TableExists	(	this IQuery	query,
		ObjectName	tableName
	)

inlinestatic

Definition at line 51 of file QueryExtensions.cs.

                                                                                 {
             return query.ObjectExists(DbObjectType.Table, tableName);
         }

static int Deveel.Data.Sql.Tables.QueryExtensions.UpdateTable	(	this IQuery	context,
		ObjectName	tableName,
		IQueryPlanNode	queryPlan,
		IEnumerable< SqlAssignExpression >	assignments,
		int	limit
	)

inlinestatic

Definition at line 91 of file QueryExtensions.Commands.cs.

                                                                      {
             var columnNames = assignments.Select(x => x.ReferenceExpression)
                 .Cast<SqlReferenceExpression>()
                 .Select(x => x.ReferenceName.Name).ToArray();
 
             if (!context.UserCanUpdateTable(tableName, columnNames))
                 throw new MissingPrivilegesException(context.UserName(), tableName, Privileges.Update);
 
             if (!context.UserCanSelectFromPlan(queryPlan))
                 throw new InvalidOperationException();
 
             var table = context.GetMutableTable(tableName);
             if (table == null)
                 throw new ObjectNotFoundException(tableName);
 
             var updateSet = queryPlan.Evaluate(context);
             return table.Update(context, updateSet, assignments, limit);
         }

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

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

Static Public Member Functions

Static Package Functions

Static Private Member Functions

Detailed Description

Member Function Documentation