//TODO: Add support as we can.
protected override DevicePlanNode InternalPrepare(Schema.DevicePlan plan, PlanNode planNode)
{
if (planNode is BaseTableVarNode)
{
BaseTableVarNode node = (BaseTableVarNode)planNode;
node.CursorType = CursorType.Dynamic;
node.RequestedCursorType = plan.Plan.CursorContext.CursorType;
node.CursorCapabilities =
CursorCapability.Navigable |
CursorCapability.BackwardsNavigable |
CursorCapability.Searchable |
CursorCapability.Updateable;
node.CursorIsolation = plan.Plan.CursorContext.CursorIsolation;
node.Order = Compiler.OrderFromKey(plan.Plan, Compiler.FindClusteringKey(plan.Plan, node.TableVar));
return(new DevicePlanNode(node));
}
else if ((planNode is OrderNode) && (planNode.Nodes[0] is BaseTableVarNode) && (plan.Plan.CursorContext.CursorType != CursorType.Static))
{
OrderNode node = (OrderNode)planNode;
BaseTableVarNode tableVarNode = (BaseTableVarNode)planNode.Nodes[0];
bool isSupported = false;
foreach (Schema.Key key in tableVarNode.TableVar.Keys)
{
var tableOrder = Compiler.OrderFromKey(plan.Plan, key);
if (node.RequestedOrder.Equivalent(tableOrder))
{
node.PhysicalOrder = tableOrder;
node.ScanDirection = ScanDirection.Forward;
isSupported = true;
break;
}
else if (node.RequestedOrder.Equivalent(new Schema.Order(tableOrder, true)))
{
node.PhysicalOrder = tableOrder;
node.ScanDirection = ScanDirection.Backward;
isSupported = true;
break;
}
}
if (!isSupported)
{
foreach (Schema.Order order in tableVarNode.TableVar.Orders)
{
//We support one column (or one column plus a single-column key ordered in the same direction).
if (order.Columns.Count > 1)
{
break;
}
if (node.RequestedOrder.Equivalent(order))
{
node.PhysicalOrder = order;
node.ScanDirection = ScanDirection.Forward;
isSupported = true;
break;
}
else if (node.RequestedOrder.Equivalent(new Schema.Order(order, true)))
{
node.PhysicalOrder = order;
node.ScanDirection = ScanDirection.Backward;
isSupported = true;
break;
}
var rowIdKey = tableVarNode.TableVar.Keys.MinimumSubsetKey(tableVarNode.TableVar.Columns);
var tableOrder = Compiler.OrderFromKey(plan.Plan, rowIdKey);
//If we have a rowId key... Add it to the ordering and see if we match
if (rowIdKey.Columns.Count == 1 && tableOrder.Columns.Count == 1)
{
Order newOrder = new Order(order);
newOrder.Columns.Add(tableOrder.Columns[0]);
if (node.RequestedOrder.Equivalent(newOrder))
{
node.PhysicalOrder = newOrder;
node.ScanDirection = ScanDirection.Forward;
isSupported = true;
break;
}
else if (node.RequestedOrder.Equivalent(new Schema.Order(newOrder, true)))
{
node.PhysicalOrder = newOrder;
node.ScanDirection = ScanDirection.Backward;
isSupported = true;
break;
}
}
}
}
if (!isSupported)
{
//Support every ordering... Use nestedFilterCursor to emulate support...
node.PhysicalOrder = node.RequestedOrder;
node.ScanDirection = ScanDirection.Forward;
isSupported = true;
}
if (isSupported)
{
node.Order = new Schema.Order();
node.Order.MergeMetaData(node.RequestedOrder.MetaData);
node.Order.IsInherited = false;
Schema.OrderColumn orderColumn;
Schema.OrderColumn newOrderColumn;
for (int index = 0; index < node.PhysicalOrder.Columns.Count; index++)
{
orderColumn = node.PhysicalOrder.Columns[index];
newOrderColumn =
new Schema.OrderColumn
(
node.TableVar.Columns[orderColumn.Column],
node.ScanDirection == ScanDirection.Forward ?
orderColumn.Ascending :
!orderColumn.Ascending
);
newOrderColumn.Sort = orderColumn.Sort;
newOrderColumn.IsDefaultSort = orderColumn.IsDefaultSort;
Error.AssertWarn(newOrderColumn.Sort != null, "Sort is null");
node.Order.Columns.Add(newOrderColumn);
}
if (!node.TableVar.Orders.Contains(node.Order))
{
node.TableVar.Orders.Add(node.Order);
}
node.CursorType = CursorType.Dynamic;
node.RequestedCursorType = plan.Plan.CursorContext.CursorType;
node.CursorCapabilities =
CursorCapability.Navigable |
CursorCapability.BackwardsNavigable |
CursorCapability.Searchable |
(plan.Plan.CursorContext.CursorCapabilities & CursorCapability.Updateable);
node.CursorIsolation = plan.Plan.CursorContext.CursorIsolation;
return(new DevicePlanNode(node));
}
}
else if (planNode is CreateTableVarBaseNode)
{
plan.Plan.CheckRight(GetRight(Schema.RightNames.CreateStore));
return(new DevicePlanNode(planNode));
}
else if (planNode is AlterTableNode)
{
//Don't support altering tables in V1
//plan.Plan.CheckRight(GetRight(Schema.RightNames.AlterStore));
//AlterTableNode alterTableNode = (AlterTableNode)planNode;
//if (alterTableNode.AlterTableStatement.CreateColumns.Count > 0)
// throw new RuntimeException(RuntimeException.Codes.UnimplementedCreateCommand, "Columns in a memory device");
//if (alterTableNode.AlterTableStatement.DropColumns.Count > 0)
// throw new RuntimeException(RuntimeException.Codes.UnimplementedDropCommand, "Columns in a memory device");
//return new DevicePlanNode(planNode);
}
else if (planNode is DropTableNode)
{
plan.Plan.CheckRight(GetRight(Schema.RightNames.DropStore));
return(new DevicePlanNode(planNode));
}
plan.IsSupported = false;
return(null);
}
protected override DevicePlanNode InternalPrepare(Schema.DevicePlan plan, PlanNode planNode)
{
if (planNode is BaseTableVarNode)
{
BaseTableVarNode node = (BaseTableVarNode)planNode;
PrepareTableNode(plan, node);
node.Order = Compiler.OrderFromKey(plan.Plan, Compiler.FindClusteringKey(plan.Plan, node.TableVar));
return(new DevicePlanNode(node));
}
else if ((planNode is OrderNode) && (planNode.Nodes[0] is BaseTableVarNode) && (plan.Plan.CursorContext.CursorType != CursorType.Static))
{
OrderNode node = (OrderNode)planNode;
BaseTableVarNode tableVarNode = (BaseTableVarNode)planNode.Nodes[0];
Schema.Order tableOrder;
bool isSupported = false;
foreach (Schema.Key key in tableVarNode.TableVar.Keys)
{
tableOrder = Compiler.OrderFromKey(plan.Plan, key);
if (node.RequestedOrder.Equivalent(tableOrder))
{
node.PhysicalOrder = tableOrder;
node.ScanDirection = ScanDirection.Forward;
isSupported = true;
break;
}
else if (node.RequestedOrder.Equivalent(new Schema.Order(tableOrder, true)))
{
node.PhysicalOrder = tableOrder;
node.ScanDirection = ScanDirection.Backward;
isSupported = true;
break;
}
}
if (!isSupported)
{
foreach (Schema.Order order in tableVarNode.TableVar.Orders)
{
if (node.RequestedOrder.Equivalent(order))
{
node.PhysicalOrder = order;
node.ScanDirection = ScanDirection.Forward;
isSupported = true;
break;
}
else if (node.RequestedOrder.Equivalent(new Schema.Order(order, true)))
{
node.PhysicalOrder = order;
node.ScanDirection = ScanDirection.Backward;
isSupported = true;
break;
}
}
}
if (isSupported)
{
node.Order = new Schema.Order();
node.Order.MergeMetaData(node.RequestedOrder.MetaData);
node.Order.IsInherited = false;
Schema.OrderColumn orderColumn;
Schema.OrderColumn newOrderColumn;
for (int index = 0; index < node.PhysicalOrder.Columns.Count; index++)
{
orderColumn = node.PhysicalOrder.Columns[index];
newOrderColumn =
new Schema.OrderColumn
(
node.TableVar.Columns[orderColumn.Column],
node.ScanDirection == ScanDirection.Forward ?
orderColumn.Ascending :
!orderColumn.Ascending
);
newOrderColumn.Sort = orderColumn.Sort;
newOrderColumn.IsDefaultSort = orderColumn.IsDefaultSort;
Error.AssertWarn(newOrderColumn.Sort != null, "Sort is null");
node.Order.Columns.Add(newOrderColumn);
}
if (!node.TableVar.Orders.Contains(node.Order))
{
node.TableVar.Orders.Add(node.Order);
}
PrepareTableNode(plan, node);
PrepareTableNode(plan, tableVarNode);
return(new DevicePlanNode(node));
}
}
else if (planNode is CreateTableVarBaseNode)
{
plan.Plan.CheckRight(GetRight(Schema.RightNames.CreateStore));
return(new DevicePlanNode(planNode));
}
else if (planNode is AlterTableNode)
{
plan.Plan.CheckRight(GetRight(Schema.RightNames.AlterStore));
AlterTableNode alterTableNode = (AlterTableNode)planNode;
if (alterTableNode.AlterTableStatement.CreateColumns.Count > 0)
{
throw new RuntimeException(RuntimeException.Codes.UnimplementedCreateCommand, "Columns in a memory device");
}
if (alterTableNode.AlterTableStatement.DropColumns.Count > 0)
{
throw new RuntimeException(RuntimeException.Codes.UnimplementedDropCommand, "Columns in a memory device");
}
return(new DevicePlanNode(planNode));
}
else if (planNode is DropTableNode)
{
plan.Plan.CheckRight(GetRight(Schema.RightNames.DropStore));
return(new DevicePlanNode(planNode));
}
plan.IsSupported = false;
return(null);
}
protected void TranslateBaseTableVarNode(CatalogDevicePlan devicePlan, CatalogDevicePlanNode devicePlanNode, BaseTableVarNode baseTableVarNode)
{
Tag tag = MetaData.GetTag(baseTableVarNode.TableVar.MetaData, "Catalog.CacheLevel");
if (tag != Tag.None)
{
if ((tag.Value == "StoreTable") || (tag.Value == "StoreView"))
{
devicePlan.TableContext = baseTableVarNode.TableVar;
baseTableVarNode.CursorType = CursorType.Dynamic;
baseTableVarNode.RequestedCursorType = devicePlan.Plan.CursorContext.CursorType;
baseTableVarNode.CursorCapabilities = CursorCapability.Navigable | (devicePlan.Plan.CursorContext.CursorCapabilities & CursorCapability.Updateable);
baseTableVarNode.CursorIsolation = devicePlan.Plan.CursorContext.CursorIsolation;
baseTableVarNode.Order = Compiler.OrderFromKey(devicePlan.Plan, Compiler.FindClusteringKey(devicePlan.Plan, baseTableVarNode.TableVar));
if (tag.Value == "StoreTable")
{
devicePlanNode.Statement.AppendFormat("select * from DAE{0}", Schema.Object.Unqualify(baseTableVarNode.TableVar.Name));
}
else
{
GetViewDefinition(Schema.Object.Unqualify(baseTableVarNode.TableVar.Name), devicePlanNode.Statement, devicePlanNode.WhereCondition);
}
}
else
{
devicePlan.IsSupported = false;
}
}
else
{
devicePlan.IsSupported = false;
}
}
private void InternalPrepare(Schema.DevicePlan plan, TableNode planNode)
{
RestrictNode restrictNode = planNode as RestrictNode;
if (restrictNode != null)
{
// Prepare the source
InternalPrepare(plan, restrictNode.SourceNode);
if (plan.IsSupported)
{
SetSearchParamContainer(plan);
if (restrictNode.IsSeekable)
{
foreach (ColumnConditions columnConditions in restrictNode.Conditions)
{
if (!IsSearchParamColumn(columnConditions.Column))
{
plan.TranslationMessages.Add(new Schema.TranslationMessage(String.Format("Service does not support restriction by {0}.", columnConditions.Column.Name)));
plan.IsSupported = false;
break;
}
}
}
else if (restrictNode.IsScanable)
{
foreach (ColumnConditions columnConditions in restrictNode.Conditions)
{
if (!IsSearchParamColumn(columnConditions.Column))
{
plan.TranslationMessages.Add(new Schema.TranslationMessage(String.Format("Service does not support restriction by {0}.", columnConditions.Column.Name)));
plan.IsSupported = false;
break;
}
foreach (ColumnCondition condition in columnConditions)
{
if (condition.Instruction != Instructions.Equal)
{
plan.IsSupported = false;
break;
}
}
if (!plan.IsSupported)
{
break;
}
}
}
else if (restrictNode.Nodes[1] is SatisfiesSearchParamNode)
{
plan.IsSupported = true;
}
else
{
plan.TranslationMessages.Add(new Schema.TranslationMessage("Service does not support arbitrary restriction."));
plan.IsSupported = false;
}
}
return;
}
BaseTableVarNode baseTableVarNode = planNode as BaseTableVarNode;
if (baseTableVarNode != null)
{
ResourceType = MetaData.GetTag(baseTableVarNode.TableVar.MetaData, "PHINVADS.ResourceType", Schema.Object.Unqualify(baseTableVarNode.TableVar.Name));
return;
}
plan.TranslationMessages.Add(new Schema.TranslationMessage("Service does not support arbitrary queries."));
plan.IsSupported = false;
return;
}
