public virtual TableMetaData getTableMetaData(string tableName)
{
TableMetaData result = new TableMetaData();
ResultSet resultSet = null;
try
{
try
{
result.TableName = tableName;
DatabaseMetaData metaData = DbSqlSession.SqlSession.Connection.MetaData;
if (DbSqlSessionFactory.POSTGRES.Equals(DbSqlSession.DbSqlSessionFactory.DatabaseType))
{
tableName = tableName.ToLower();
}
string databaseSchema = DbSqlSession.DbSqlSessionFactory.DatabaseSchema;
tableName = DbSqlSession.prependDatabaseTablePrefix(tableName);
resultSet = metaData.getColumns(null, databaseSchema, tableName, null);
while (resultSet.next())
{
string name = resultSet.getString("COLUMN_NAME").ToUpper();
string type = resultSet.getString("TYPE_NAME").ToUpper();
result.addColumnMetaData(name, type);
}
}
catch (SQLException se)
{
throw se;
}
finally
{
if (resultSet != null)
{
resultSet.close();
}
}
}
catch (Exception e)
{
throw LOG.retrieveMetadataException(e);
}
if (result.ColumnNames.Count == 0)
{
// According to API, when a table doesn't exist, null should be returned
result = null;
}
return(result);
}
public AggregationServiceFactoryForgeTable(
TableMetaData metadata,
TableColumnMethodPairForge[] methodPairs,
int[] accessColumnsZeroOffset,
AggregationAgentForge[] accessAgents,
AggregationGroupByRollupDescForge groupByRollupDesc)
{
this.metadata = metadata;
this.methodPairs = methodPairs;
this.accessColumnsZeroOffset = accessColumnsZeroOffset;
this.accessAgents = accessAgents;
this.groupByRollupDesc = groupByRollupDesc;
}
public ExprTableIdentNodeSubpropAccessor(
int streamNum,
string optionalStreamName,
TableMetaData table,
TableMetadataColumnAggregation tableAccessColumn,
ExprNode aggregateAccessMultiValueNode)
{
_streamNum = streamNum;
_optionalStreamName = optionalStreamName;
_table = table;
_tableAccessColumn = tableAccessColumn;
_aggregateAccessMultiValueNode = aggregateAccessMultiValueNode;
}
public OnSplitItemForge(
ExprNode whereClause,
bool isNamedWindowInsert,
TableMetaData insertIntoTable,
ResultSetProcessorDesc resultSetProcessorDesc,
PropertyEvaluatorForge propertyEvaluator)
{
WhereClause = whereClause;
IsNamedWindowInsert = isNamedWindowInsert;
InsertIntoTable = insertIntoTable;
ResultSetProcessorDesc = resultSetProcessorDesc;
PropertyEvaluator = propertyEvaluator;
}
public void Add(
string tableName,
TableMetaData metadata,
EPStatementInitServices services)
{
Table existing = tables.Get(tableName);
if (existing != null) {
throw new IllegalStateException("Table already found for name '" + tableName + "'");
}
Table table = services.TableManagementService.AllocateTable(metadata);
tables.Put(tableName, table);
}
public void AddTable(
string tableName,
TableMetaData tableMetaData,
EPStatementInitServices services)
{
var deployment = deployments.Get(services.DeploymentId);
if (deployment == null) {
deployment = new TableDeployment();
deployments.Put(services.DeploymentId, deployment);
}
deployment.Add(tableName, tableMetaData, services);
}
private void parseColumnDefinition(TResultColumn resultColumn, TableMetaData viewMetaData, ColumnImpactModel columnImpactModel, string aliasName)
{
ColumnMetaData columnMetaData = new ColumnMetaData();
columnMetaData.Table = viewMetaData;
if (resultColumn != null)
{
if (resultColumn.AliasClause != null)
{
columnMetaData.Name = resultColumn.AliasClause.AliasName.ToString();
}
else if (isNotEmpty(resultColumn.ColumnNameOnly))
{
columnMetaData.Name = resultColumn.ColumnNameOnly;
}
else
{
columnMetaData.Name = resultColumn.ToString();
}
}
if (!string.ReferenceEquals(aliasName, null))
{
columnMetaData.DisplayName = aliasName;
}
if (tableColumns[viewMetaData] == null)
{
return;
}
int index = tableColumns[viewMetaData].IndexOf(columnMetaData);
if (index != -1)
{
columnMetaData = tableColumns[viewMetaData][index];
}
else
{
tableColumns[viewMetaData].Add(columnMetaData);
}
if (resultColumn != null)
{
ColumnMetaData[] referColumns = getRefTableColumns(resultColumn, columnImpactModel);
for (int i = 0; i < referColumns.Length; i++)
{
columnMetaData.addReferColumn(referColumns[i]);
}
}
}
public InfraOnMergeActionInsForge(
ExprNode optionalFilter,
SelectExprProcessorForge insertHelper,
TableMetaData insertIntoTable,
bool audit,
bool route)
: base(optionalFilter)
{
this.insertHelper = insertHelper;
this.insertIntoTable = insertIntoTable;
this.audit = audit;
this.route = route;
}
public virtual void testGetTableMetaDataAsCamundaAdmin()
{
// given
//identityService.SetAuthentication(userId, Collections.singletonList(Groups.GroupsFields.CamundaAdmin));
identityService.SetAuthentication(userId, new List <string>()
{
GroupsFields.CamundaAdmin
});
// when
TableMetaData tableMetaData = managementService.GetTableMetaData("ACT_RE_PROCDEF");
// then
Assert.NotNull(tableMetaData);
}
public void ShouldReturnListOfColumnsMatchingThePropertiesOfRowTypePassedToConstructor()
{
// Given
var table = new TableMetaData <TestEntity>();
// When
var columns = table.Columns;
// Then
var columnNames = from c in columns
select c.ColumnName;
columnNames.ShouldBeEquivalentTo(new string[] { "Id", "RequiredInt", "NullableInt", "RequiredString", "NullableString" });
}
public void ShouldReturnAllColumnsExceptIdWhenExcludeIdIsTrue()
{
// Given
var table = new TableMetaData <TestEntity>();
// When
var columns = table.GetColumns(excludeId: true);
// Then
var columnNames = from c in columns
select c.ColumnName;
columnNames.ShouldBeEquivalentTo(new string[] { "RequiredInt", "NullableInt", "RequiredString", "NullableString" });
}
public ColumnMetaData[] Columns(TableMetaData filter)
{
_connection.Open();
var table = _connection.GetSchema("Columns");
_connection.Close();
var selectedRows =
from info in table.AsEnumerable()
select new ColumnMetaData(
new TableMetaData(info["TABLE_SCHEMA"].ToString(), info["TABLE_NAME"].ToString())
, info["COLUMN_NAME"].ToString()
, info["DATA_TYPE"].ToString());
return(selectedRows.Where(z => z.Table.Equals(filter)).ToArray());
}
public ExprTableIdentNode(
TableMetaData tableMetadata,
string streamOrPropertyName,
string unresolvedPropertyName,
Type returnType,
int streamNum,
int columnNum)
{
this.tableMetadata = tableMetadata;
this.streamOrPropertyName = streamOrPropertyName;
this.unresolvedPropertyName = unresolvedPropertyName;
this.returnType = returnType;
this.streamNum = streamNum;
this.columnNum = columnNum;
}
public OutputStrategyPostProcessForge(
bool isRouted,
SelectClauseStreamSelectorEnum? insertIntoStreamSelector,
SelectClauseStreamSelectorEnum selectStreamSelector,
bool routeToFront,
TableMetaData table,
bool audit)
{
this.isRouted = isRouted;
this.insertIntoStreamSelector = insertIntoStreamSelector;
this.selectStreamSelector = selectStreamSelector;
this.routeToFront = routeToFront;
this.table = table;
this.audit = audit;
}
protected void ValidateGroupKeys(
TableMetaData metadata,
ExprValidationContext validationContext)
{
if (ChildNodes.Length > 0) {
groupKeyEvaluators = ExprNodeUtilityQuery.GetForges(ChildNodes);
}
else {
groupKeyEvaluators = new ExprForge[0];
}
var typesReturned = ExprNodeUtilityQuery.GetExprResultTypes(ChildNodes);
var keyTypes = metadata.IsKeyed ? metadata.KeyTypes : new Type[0];
ExprTableNodeUtil.ValidateExpressions(TableName, typesReturned, "key", ChildNodes, keyTypes, "key");
}
public static CodegenExpressionInstanceField MakeTableEventToPublicField(
TableMetaData table,
CodegenClassScope classScope,
Type generator)
{
var symbols = new SAIFFInitializeSymbol();
CodegenMethod tableInit = classScope.NamespaceScope.InitMethod
.MakeChildWithScope(typeof(TableMetadataInternalEventToPublic), generator, symbols, classScope)
.AddParam(typeof(EPStatementInitServices), EPStatementInitServicesConstants.REF.Ref);
var tableResolve = MakeResolveTable(table, EPStatementInitServicesConstants.REF);
tableInit.Block.MethodReturn(ExprDotName(tableResolve, "EventToPublic"));
return classScope.NamespaceScope.AddDefaultFieldUnshared(
true,
typeof(TableMetadataInternalEventToPublic),
LocalMethod(tableInit, EPStatementInitServicesConstants.REF));
}
public static IQueryable <T> ApplyOrdering <T>(this IQueryable <T> query, TableMetaData queryObj, string defaultSortField, Dictionary <string, Expression <Func <T, object> > > columnsMap)
{
if (String.IsNullOrWhiteSpace(queryObj.sortField) || !columnsMap.ContainsKey(queryObj.sortField))
{
return(query.OrderByDescending(columnsMap[defaultSortField]));
}
if (queryObj.sortOrder == 0)
{
return(query.OrderBy(columnsMap[queryObj.sortField]));
}
else
{
return(query.OrderByDescending(columnsMap[queryObj.sortField]));
}
}
public virtual void testGetTableMetaData()
{
TableMetaData tableMetaData = managementService.getTableMetaData("ACT_RU_TASK");
assertEquals(tableMetaData.ColumnNames.Count, tableMetaData.ColumnTypes.Count);
assertEquals(21, tableMetaData.ColumnNames.Count);
int assigneeIndex = tableMetaData.ColumnNames.IndexOf("ASSIGNEE_");
int createTimeIndex = tableMetaData.ColumnNames.IndexOf("CREATE_TIME_");
assertTrue(assigneeIndex >= 0);
assertTrue(createTimeIndex >= 0);
assertOneOf(new string[] { "VARCHAR", "NVARCHAR2", "nvarchar", "NVARCHAR" }, tableMetaData.ColumnTypes[assigneeIndex]);
assertOneOf(new string[] { "TIMESTAMP", "TIMESTAMP(6)", "datetime", "DATETIME", "DATETIME2" }, tableMetaData.ColumnTypes[createTimeIndex]);
}
private static EventTableIndexMetadata GetIndexMetadata(
ModuleIndexMeta objectName,
string moduleName,
EPServicesPath paths)
{
if (objectName.IsNamedWindow)
{
NamedWindowMetaData metaData = paths.NamedWindowPathRegistry.GetWithModule(objectName.InfraName, moduleName);
return(metaData?.IndexMetadata);
}
else
{
TableMetaData metaData = paths.TablePathRegistry.GetWithModule(objectName.InfraName, moduleName);
return(metaData?.IndexMetadata);
}
}
private ColumnMetaData getColumn(ColumnModel column)
{
if (column == null)
{
return(null);
}
string tableFullName = column.Table.FullName;
IList <string> splits = new List <string>(tableFullName.Split(new char[] { '.' }));
ColumnMetaData columnMetadata = new ColumnMetaData();
columnMetadata.Name = column.Name;
TableMetaData tableMetaData = new TableMetaData(vendor, strict);
if (splits.Count > 0)
{
tableMetaData.Name = splits[splits.Count - 1];
}
if (splits.Count > 1)
{
tableMetaData.SchemaName = splits[splits.Count - 2];
}
if (splits.Count > 2)
{
tableMetaData.CatalogName = splits[splits.Count - 3];
}
if (!tableColumns.ContainsKey(tableMetaData))
{
tableColumns[tableMetaData] = new List <ColumnMetaData>();
}
else
{
IList <TableMetaData> tables = new List <TableMetaData>(tableColumns.Keys);
tableMetaData = tables[tables.IndexOf(tableMetaData)];
}
columnMetadata.Table = tableMetaData;
IList <ColumnMetaData> columns = tableColumns[tableMetaData];
if (columns.Contains(columnMetadata))
{
columnMetadata = columns[columns.IndexOf(columnMetadata)];
}
else
{
columns.Add(columnMetadata);
}
return(columnMetadata);
}
public StatementAgentInstanceFactoryOnTriggerInfraBaseForge(
ViewableActivatorForge activator,
EventType resultEventType,
IDictionary<ExprSubselectNode, SubSelectFactoryForge> subselects,
IDictionary<ExprTableAccessNode, ExprTableEvalStrategyFactoryForge> tableAccesses,
string nonSelectRSPProviderClassName,
NamedWindowMetaData namedWindow,
TableMetaData table,
SubordinateWMatchExprQueryPlanForge queryPlanForge)
: base(activator, resultEventType, subselects, tableAccesses)
{
this.nonSelectRSPProviderClassName = nonSelectRSPProviderClassName;
this.namedWindow = namedWindow;
this.table = table;
this.queryPlanForge = queryPlanForge;
}
public StatementAgentInstanceFactoryCreateIndexForge(
EventType eventType,
string indexName,
string indexModuleName,
QueryPlanIndexItemForge explicitIndexDesc,
IndexMultiKey imk,
NamedWindowMetaData namedWindow,
TableMetaData table)
{
this.eventType = eventType;
this.indexName = indexName;
this.indexModuleName = indexModuleName;
this.explicitIndexDesc = explicitIndexDesc;
this.imk = imk;
this.namedWindow = namedWindow;
this.table = table;
}
private ICollection <IndexMetaData> GetIndexMetaDataList(TableMetaData tableMetaData, TableRule tableRule)
{
ICollection <IndexMetaData> result = new HashSet <IndexMetaData>();
foreach (var indexMeta in tableMetaData.GetIndexes())
{
foreach (var actualDataNode in tableRule.ActualDataNodes)
{
var logicIndex = GetLogicIndex(indexMeta.Key, actualDataNode.GetTableName());
if (logicIndex != null)
{
result.Add(new IndexMetaData(logicIndex));
}
}
}
return(result);
}
public ExprTableIdentNode(
TableMetaData tableMetadata,
string streamOrPropertyName,
string unresolvedPropertyName,
Type returnType,
int streamNum,
string columnName,
int columnNum)
{
_tableMetadata = tableMetadata;
_streamOrPropertyName = streamOrPropertyName;
_unresolvedPropertyName = unresolvedPropertyName;
EvaluationType = returnType;
_streamNum = streamNum;
_columnNum = columnNum;
_columnName = columnName;
}
private bool GetValueCaseSensitiveFromTables(IStreamDataReader streamDataReader, SelectCommandContext selectCommandContext,
SchemaMetaData schemaMetaData, int columnIndex)
{
foreach (var simpleTableSegment in selectCommandContext.GetAllTables())
{
String tableName = simpleTableSegment.GetTableName().GetIdentifier().GetValue();
TableMetaData tableMetaData = schemaMetaData.Get(tableName);
IDictionary <String, ColumnMetaData> columns = tableMetaData.GetColumns();
String columnName = streamDataReader.GetColumnName(columnIndex);
if (columns.ContainsKey(columnName))
{
return(columns[columnName].CaseSensitive);
}
}
return(false);
}
private static TableLookupPlanDesc GetFullTableScanTable(
int lookupStream,
int indexedStream,
bool indexedStreamIsVDW,
EventType[] typesPerStream,
TableMetaData indexedStreamTableMeta)
{
var indexName = new TableLookupIndexReqKey(
indexedStreamTableMeta.TableName,
indexedStreamTableMeta.TableModuleName,
indexedStreamTableMeta.TableName);
var forge = new FullTableScanUniquePerKeyLookupPlanForge(
lookupStream,
indexedStream,
indexedStreamIsVDW,
typesPerStream,
indexName);
return new TableLookupPlanDesc(forge, EmptyList<StmtClassForgeableFactory>.Instance);
}
public void ShouldThrowExceptionWhenCreateTableCommandDoesNotReturnZero()
{
// Given
var connection = new FakeDbConnection(openConnection: true);
var language = new FakeDbLanguage();
var database = new Database <FakeDbConnection, FakeDbLanguage>(connection, language);
var table = new TableMetaData <TestEntity>();
connection.CreateCommandFactory = () => new FakeDbCommand()
{
ReturnValueForExecuteNonQuery = 1
};
// When
Action action = () => database.CreateTable(table);
// Then
action.ShouldThrow <Exception>().WithMessage("CREATE TABLE returned 1. Expected value to be 0.");
}
public async Task <QueryResult <SPEducation> > GetSPEducationViewList(TableMetaData tableMetaData)
{
QueryResult <SPEducation> result = new QueryResult <SPEducation>();
var query = _context.SPEducations.Where(x => x.Active)
.AsQueryable();
//filters
if (tableMetaData.filters != null)
{
foreach (string itemKey in tableMetaData.filters.Keys)
{
string value = tableMetaData.filters[itemKey];
switch (itemKey)
{
case "nameRu":
query = _context.SPEducations.Where(x => x.NameRu.Contains(value));
break;
case "nameUz":
query = _context.SPEducations.Where(x => x.NameUz.Contains(value));
break;
}
}
}
//sort
var columnsMap = new Dictionary <string, Expression <Func <SPEducation, object> > >()
{
["nameRu"] = v => v.NameRu,
};
//По умолчанию
query = query.ApplyOrdering(tableMetaData, "nameRu", columnsMap);
result.TotalItems = await query.CountAsync();
List <SPEducation> datas = await query
.Skip(tableMetaData.first.Value)
.Take(tableMetaData.rows.Value).ToListAsync();
result.Items = datas;
return(result);
}
private void parseInsertStmt(TInsertSqlStatement insert)
{
if (insert.TargetTable.TableName != null)
{
string tableName = insert.TargetTable.TableName.TableString;
string tableSchema = insert.TargetTable.TableName.SchemaString;
string databaseName = insert.TargetTable.TableName.DatabaseString;
TableMetaData tableMetaData = new TableMetaData(vendor, strict);
tableMetaData.Name = tableName;
tableMetaData.SchemaName = tableSchema;
if (isNotEmpty(databaseName))
{
tableMetaData.CatalogName = databaseName;
}
else
{
tableMetaData.CatalogName = database;
}
tableMetaData.View = false;
if (!tableColumns.ContainsKey(tableMetaData))
{
tableColumns[tableMetaData] = new List <ColumnMetaData>();
}
else
{
IList <TableMetaData> tables = new List <TableMetaData>(tableColumns.Keys);
tableMetaData = (TableMetaData)tables[tables.IndexOf(tableMetaData)];
tableMetaData.View = false;
}
if (insert.SubQuery != null)
{
ColumnImpact impact = new ColumnImpact(insert.SubQuery.ToString(), insert.dbvendor, tableColumns, strict);
impact.ignoreTopSelect(true);
impact.Debug = false;
impact.ShowUIInfo = true;
impact.TraceErrorMessage = false;
impact.impactSQL();
ColumnImpactModel columnImpactModel = impact.generateModel();
parseSubQueryColumnDefinition(insert, insert.SubQuery, tableMetaData, columnImpactModel);
}
}
}
public DatabaseMetadata GetAllTables(String connectionString)
{
var result = new DatabaseMetadata();
SqlConnection con =
new SqlConnection(connectionString);
result.DatabaseType = DatabaseType.MsSql;
try
{
con.Open();
result.DatabaseName = con.Database;
DataTable tblDatabases =
con.GetSchema(
SqlClientMetaDataCollectionNames.Tables);
var list = new List <TableMetaData>();
foreach (DataRow rowDatabase in tblDatabases.Rows)
{
var i = new TableMetaData();
i.TableCatalog = rowDatabase["table_catalog"].ToStr();
i.TableSchema = rowDatabase["table_schema"].ToStr();
i.TableName = rowDatabase["table_name"].ToStr();
i.TableType = rowDatabase["table_type"].ToStr();
list.Add(i);
}
con.Close();
result.ConnectionString = connectionString;
result.Tables = list.OrderBy(t => t.TableName).ToList();
}
catch (Exception e)
{
}
return(result);
}
