private static OracleTypeCollection MapCollectionTypeAttributes(IDataRecord reader, IDictionary <OracleObjectIdentifier, OracleSchemaObject> allObjects) { var typeFullyQualifiedName = OracleObjectIdentifier.Create(QualifyStringObject(reader["OWNER"]), QualifyStringObject(reader["TYPE_NAME"])); if (!allObjects.TryGetValue(typeFullyQualifiedName, out OracleSchemaObject typeObject)) { return(null); } var collectionType = (OracleTypeCollection)typeObject; var elementTypeIdentifier = OracleObjectIdentifier.Create(QualifyStringObject(reader["ELEM_TYPE_OWNER"]), QualifyStringObject(reader["ELEM_TYPE_NAME"])); var dataType = new OracleDataType { FullyQualifiedName = elementTypeIdentifier, Length = OracleReaderValueConvert.ToInt32(reader["LENGTH"]), Precision = OracleReaderValueConvert.ToInt32(reader["PRECISION"]), Scale = OracleReaderValueConvert.ToInt32(reader["SCALE"]) }; ResolveDataUnit(dataType, reader["CHARACTER_SET_NAME"]); collectionType.ElementDataType = dataType; collectionType.CollectionType = (string)reader["COLL_TYPE"] == OracleTypeCollection.OracleCollectionTypeNestedTable ? OracleCollectionType.Table : OracleCollectionType.VarryingArray; collectionType.UpperBound = OracleReaderValueConvert.ToInt32(reader["UPPER_BOUND"]); return(collectionType); }
private static KeyValuePair <OracleObjectIdentifier, OracleColumn> MapTableColumn(IDataRecord reader, Version version) { var dataTypeIdentifier = OracleObjectIdentifier.Create(QualifyStringObject(reader["DATA_TYPE_OWNER"]), QualifyStringObject(reader["DATA_TYPE"])); var dataType = new OracleDataType { FullyQualifiedName = dataTypeIdentifier, Length = Convert.ToInt32(reader["DATA_LENGTH"]), Precision = OracleReaderValueConvert.ToInt32(reader["DATA_PRECISION"]), Scale = OracleReaderValueConvert.ToInt32(reader["DATA_SCALE"]) }; ResolveDataUnit(dataType, reader["CHAR_USED"]); var column = new OracleColumn { Name = QualifyStringObject(reader["COLUMN_NAME"]), DataType = dataType, Nullable = String.Equals((string)reader["NULLABLE"], "Y"), Virtual = String.Equals((string)reader["VIRTUAL_COLUMN"], "YES"), DefaultValue = OracleReaderValueConvert.ToString(reader["DATA_DEFAULT"]), CharacterSize = Convert.ToInt32(reader["CHAR_LENGTH"]), UserGenerated = true }; if (version.Major >= 12) { column.Hidden = String.Equals((string)reader["HIDDEN_COLUMN"], "YES"); column.UserGenerated = String.Equals((string)reader["USER_GENERATED"], "YES"); } return(new KeyValuePair <OracleObjectIdentifier, OracleColumn>( OracleObjectIdentifier.Create(QualifyStringObject(reader["OWNER"]), QualifyStringObject(reader["TABLE_NAME"])), column)); }
public void TestBasicInitialization() { var plsqlText = $"CREATE OR REPLACE FUNCTION TEST_FUNCTION(p1 IN NUMBER DEFAULT 0, p2 IN OUT VARCHAR2, p3 OUT NOCOPY CLOB) RETURN RAW IS {TestPlSqlProgramBase}"; var statement = (OracleStatement)Parser.Parse(plsqlText).Single(); statement.ParseStatus.ShouldBe(ParseStatus.Success); var expectedObjectIdentifier = OracleObjectIdentifier.Create("HUSQVIK", "TEST_FUNCTION"); var semanticModel = new OraclePlSqlStatementSemanticModel(plsqlText, statement, TestFixture.DatabaseModel).Build(CancellationToken.None); semanticModel.Programs.Count.ShouldBe(1); var mainProgram = semanticModel.Programs[0]; mainProgram.ObjectIdentifier.ShouldBe(expectedObjectIdentifier); mainProgram.Name.ShouldBe("\"TEST_FUNCTION\""); mainProgram.Parameters.Count.ShouldBe(3); mainProgram.Parameters[0].Name.ShouldBe("\"P1\""); mainProgram.Parameters[0].Direction.ShouldBe(ParameterDirection.Input); mainProgram.Parameters[1].Name.ShouldBe("\"P2\""); mainProgram.Parameters[1].Direction.ShouldBe(ParameterDirection.InputOutput); mainProgram.Parameters[2].Name.ShouldBe("\"P3\""); mainProgram.Parameters[2].Direction.ShouldBe(ParameterDirection.Output); mainProgram.ReturnParameter.ShouldNotBe(null); AssertMainProgram(mainProgram, expectedObjectIdentifier); }
public OracleDatabaseLink GetFirstDatabaseLink(params OracleObjectIdentifier[] identifiers) { DatabaseLinks.TryGetFirstValue(out var databaseLink, identifiers); if (databaseLink == null) { foreach (var link in DatabaseLinks.Values) { var databaseLinkNormalizedName = link.FullyQualifiedName.NormalizedName; var instanceQualifierIndex = databaseLinkNormalizedName.IndexOf("@", StringComparison.InvariantCulture); if (instanceQualifierIndex == -1) { continue; } var shortName = databaseLinkNormalizedName.Substring(1, instanceQualifierIndex - 1).ToQuotedIdentifier(); var shortIdentifier = OracleObjectIdentifier.Create(link.FullyQualifiedName.Owner, shortName); if (identifiers.Any(i => i == shortIdentifier)) { databaseLink = link; break; } } } return(databaseLink); }
private static OracleTypeObject MapTypeAttributes(IDataRecord reader, IDictionary <OracleObjectIdentifier, OracleSchemaObject> allObjects) { var typeFullyQualifiedName = OracleObjectIdentifier.Create(QualifyStringObject(reader["OWNER"]), QualifyStringObject(reader["TYPE_NAME"])); if (!allObjects.TryGetValue(typeFullyQualifiedName, out OracleSchemaObject typeObject)) { return(null); } var type = (OracleTypeObject)typeObject; var attributeTypeIdentifier = OracleObjectIdentifier.Create(QualifyStringObject(reader["ATTR_TYPE_OWNER"]), QualifyStringObject(reader["ATTR_TYPE_NAME"])); var dataType = new OracleDataType { FullyQualifiedName = attributeTypeIdentifier, Length = OracleReaderValueConvert.ToInt32(reader["LENGTH"]), Precision = OracleReaderValueConvert.ToInt32(reader["PRECISION"]), Scale = OracleReaderValueConvert.ToInt32(reader["SCALE"]) }; ResolveDataUnit(dataType, reader["CHAR_USED"]); var attribute = new OracleTypeAttribute { Name = QualifyStringObject(reader["ATTR_NAME"]), DataType = dataType, IsInherited = String.Equals((string)reader["INHERITED"], "YES") }; type.Attributes.Add(attribute); return(type); }
private static OracleTable GetTableForPartition(IDataRecord reader, IDictionary <OracleObjectIdentifier, OracleSchemaObject> allObjects) { var tableFullyQualifiedName = OracleObjectIdentifier.Create(QualifyStringObject(reader["TABLE_OWNER"]), QualifyStringObject(reader["TABLE_NAME"])); return(allObjects.TryGetValue(tableFullyQualifiedName, out OracleSchemaObject schemaObject) ? (OracleTable)schemaObject : null); }
private OracleObjectIdentifier[] GetCurrentAndPublicSchemaIdentifiers(string name) { return (new[] { OracleObjectIdentifier.Create(CurrentSchema, name), OracleObjectIdentifier.Create(OracleObjectIdentifier.SchemaPublic, name) }); }
public override void InitializeCommand(OracleCommand command) { command.CommandText = OracleDatabaseCommands.SelectIndexColumnDescriptionCommandText; command.AddSimpleParameter("OWNER", _objectIdentifier.Owner.Trim('"')); command.AddSimpleParameter("TABLE_NAME", _objectIdentifier.Name.Trim('"')); command.AddSimpleParameter("COLUMN_NAME", String.IsNullOrEmpty(_columnName) ? null : _columnName.Trim('"')); _indexes = DataModel.IndexDetails.ToDictionary(i => OracleObjectIdentifier.Create(i.Owner, i.Name)); }
private static void EnsureDocumentationDictionaries() { if (_packageProgramDocumentations != null) { return; } lock (LockObject) { if (_packageProgramDocumentations != null) { return; } var folder = Path.GetDirectoryName(new Uri(typeof(OracleHelpProvider).Assembly.CodeBase).LocalPath); using (var reader = XmlReader.Create(Path.Combine(folder, "OracleDocumentation.xml"))) { var documentation = (Documentation) new XmlSerializer(typeof(Documentation)).Deserialize(reader); _sqlFunctionDocumentation = documentation.Functions.ToLookup(f => f.Name.ToQuotedIdentifier()); _statementDocumentation = documentation.Statements.ToLookup(s => s.Name); var dataDictionaryObjects = documentation.DataDictionary.ToDictionary(o => OracleObjectIdentifier.Create(OracleObjectIdentifier.SchemaSys, o.Name)); _dataDictionaryObjects = dataDictionaryObjects.AsReadOnly(); var packageProgramDocumentations = new Dictionary <OracleProgramIdentifier, DocumentationPackageSubProgram>(); foreach (var packageDocumentation in documentation.Packages) { var packageIdentifier = OracleObjectIdentifier.Create(OracleObjectIdentifier.SchemaSys, packageDocumentation.Name); var dataDictionaryObjectDocumentation = new DocumentationDataDictionaryObject { Name = packageDocumentation.Name, Value = packageDocumentation.Description, Url = packageDocumentation.Url }; dataDictionaryObjects.Add(packageIdentifier, dataDictionaryObjectDocumentation); if (packageDocumentation.SubPrograms == null) { continue; } foreach (var subProgramDocumentation in packageDocumentation.SubPrograms) { subProgramDocumentation.PackageDocumentation = packageDocumentation; packageProgramDocumentations[OracleProgramIdentifier.CreateFromValues(OracleObjectIdentifier.SchemaSys, packageDocumentation.Name, subProgramDocumentation.Name)] = subProgramDocumentation; } } _packageProgramDocumentations = packageProgramDocumentations.AsReadOnly(); } } }
public ProgramMetadataResult GetProgramMetadata(OracleProgramIdentifier identifier, int parameterCount, bool forceBuiltInFunction, bool hasAnalyticClause, bool includePlSqlObjects) { var result = new ProgramMetadataResult(); OracleSchemaObject schemaObject; IEnumerable <OracleProgramMetadata> programMetadataSource = new List <OracleProgramMetadata>(); if (String.IsNullOrEmpty(identifier.Package) && (forceBuiltInFunction || String.IsNullOrEmpty(identifier.Owner))) { var builtInProgramPackage = OracleObjectIdentifier.IdentifierBuiltInFunctionPackage; var programIdentifier = OracleProgramIdentifier.CreateFromValues(builtInProgramPackage.Owner, builtInProgramPackage.Name, identifier.Name); if (AllObjects.TryGetValue(builtInProgramPackage, out schemaObject)) { programMetadataSource = BuiltInPackageProgramMetadata[programIdentifier]; } result.Metadata = TryFindProgramOverload(programMetadataSource, identifier.Name, parameterCount, hasAnalyticClause, !forceBuiltInFunction && includePlSqlObjects); if (result.Metadata == null) { if (includePlSqlObjects && AllObjects.TryGetValue(OracleObjectIdentifier.IdentifierDbmsStandard, out schemaObject)) { programIdentifier = OracleProgramIdentifier.CreateFromValues(builtInProgramPackage.Owner, OracleObjectIdentifier.PackageDbmsStandard, identifier.Name); programMetadataSource = BuiltInPackageProgramMetadata[programIdentifier]; result.Metadata = TryFindProgramOverload(programMetadataSource, identifier.Name, parameterCount, hasAnalyticClause, true); } if (result.Metadata == null) { var nonSchemaBuiltInFunctionIdentifier = OracleProgramIdentifier.CreateBuiltIn(identifier.Name); result.Metadata = TryFindProgramOverload(NonSchemaBuiltInFunctionMetadata[nonSchemaBuiltInFunctionIdentifier], identifier.Name, parameterCount, hasAnalyticClause, includePlSqlObjects); } } result.SchemaObject = schemaObject; } if (result.Metadata == null) { var schemaObjectFound = (String.IsNullOrWhiteSpace(identifier.Package) && AllObjects.TryGetValue(OracleObjectIdentifier.Create(identifier.Owner, identifier.Name), out schemaObject)) || AllObjects.TryGetValue(OracleObjectIdentifier.Create(identifier.Owner, identifier.Package), out schemaObject); if (!schemaObjectFound || !TryGetSchemaObjectProgramMetadata(schemaObject, out programMetadataSource)) { return(result); } result.SchemaObject = schemaObject; var programName = String.IsNullOrEmpty(identifier.Package) ? schemaObject.GetTargetSchemaObject().Name : identifier.Name; result.Metadata = TryFindProgramOverload(programMetadataSource, programName, parameterCount, hasAnalyticClause, includePlSqlObjects); } return(result); }
public OracleObjectIdentifier GetExplainPlanTargetTable(string connectionName) { if ((_connectionConfigurations.TryGetValue(connectionName, out OracleConfigurationConnection configuration) && configuration.ExecutionPlan?.TargetTable != null) || _connectionConfigurations.TryGetValue(AllConnections, out configuration) && configuration.ExecutionPlan?.TargetTable != null) { var targetTable = configuration.ExecutionPlan.TargetTable; return(OracleObjectIdentifier.Create(targetTable.Schema, targetTable.Name)); } return(OracleObjectIdentifier.Empty); }
private OracleObjectIdentifier CreateObjectIdentifierFromSchemaObjectNode(StatementGrammarNode schemaObjectNode) { if (schemaObjectNode == null) { return(OracleObjectIdentifier.Empty); } var owner = schemaObjectNode[NonTerminals.SchemaPrefix, Terminals.SchemaIdentifier]?.Token.Value ?? DatabaseModel.CurrentSchema; var name = schemaObjectNode[Terminals.ObjectIdentifier]?.Token.Value; return(OracleObjectIdentifier.Create(owner, name)); }
private static OracleDatabaseLink MapDatabaseLink(IDataRecord reader) { var databaseLinkFullyQualifiedName = OracleObjectIdentifier.Create(QualifyStringObject(reader["OWNER"]), QualifyStringObject(reader["DB_LINK"])); return (new OracleDatabaseLink { FullyQualifiedName = databaseLinkFullyQualifiedName, Created = (DateTime)reader["CREATED"], Host = (string)reader["HOST"], UserName = OracleReaderValueConvert.ToString(reader["USERNAME"]) }); }
private static OracleTable MapTable(IDataRecord reader, IDictionary <OracleObjectIdentifier, OracleSchemaObject> allObjects) { var tableFullyQualifiedName = OracleObjectIdentifier.Create(QualifyStringObject(reader["OWNER"]), QualifyStringObject(reader["TABLE_NAME"])); if (!allObjects.TryGetValue(tableFullyQualifiedName, out OracleSchemaObject schemaObject)) { return(null); } var table = (OracleTable)schemaObject; table.Organization = (OrganizationType)Enum.Parse(typeof(OrganizationType), (string)reader["ORGANIZATION"]); return(table); }
private static OracleDirectory MapDirectory(IDataRecord reader, IDictionary <OracleObjectIdentifier, OracleSchemaObject> allObjects) { var directoryFullyQualifiedName = OracleObjectIdentifier.Create(QualifyStringObject(reader["OWNER"]), QualifyStringObject(reader["DIRECTORY_NAME"])); if (!allObjects.TryGetValue(directoryFullyQualifiedName, out OracleSchemaObject schemaObject)) { return(null); } var directory = (OracleDirectory)schemaObject; directory.Path = (string)reader["DIRECTORY_PATH"]; return(directory); }
private static OracleObjectIdentifier GetObjectIdentifierFromNode(StatementGrammarNode node) { if (node == null) { return(OracleObjectIdentifier.Empty); } var schemaIdentifierTerminal = node[NonTerminals.SchemaPrefix, Terminals.SchemaIdentifier]; var objectIdentifierTerminal = node[Terminals.ObjectIdentifier]; return(objectIdentifierTerminal == null ? OracleObjectIdentifier.Empty : OracleObjectIdentifier.Create(schemaIdentifierTerminal, objectIdentifierTerminal, null)); }
public static OracleObjectIdentifier ExtractObjectIdentifier(this StatementGrammarNode node) { var queryTableExpression = node.GetPathFilterAncestor(n => !String.Equals(n.Id, NonTerminals.FromClause), NonTerminals.QueryTableExpression); var tableIdentifierNode = queryTableExpression.ChildNodes.SingleOrDefault(n => String.Equals(n.Id, Terminals.ObjectIdentifier)); if (tableIdentifierNode == null) { return(OracleObjectIdentifier.Empty); } var schemaPrefixNode = queryTableExpression.ChildNodes.SingleOrDefault(n => String.Equals(n.Id, NonTerminals.SchemaPrefix)); schemaPrefixNode = schemaPrefixNode?.ChildNodes.First(); return(OracleObjectIdentifier.Create(schemaPrefixNode, tableIdentifierNode, null)); }
private async Task ConfigureSettings(CancellationToken cancellationToken) { ExecutionContext.EnsureSettingsProviderAvailable(); _settingsModel = ExecutionContext.SettingsProvider.Settings; _settingsModel.IsTextInputVisible = false; var expandedColumns = new List <ColumnDescriptionItem>(); var databaseLinkReferences = new List <OracleObjectWithColumnsReference>(); _asteriskNode = FillColumnNames(expandedColumns, databaseLinkReferences, true); var useDefaultSettings = _settingsModel.UseDefaultSettings == null || _settingsModel.UseDefaultSettings(); foreach (var databaseLinkReference in databaseLinkReferences) { var databaseLinkIdentifier = String.Concat(databaseLinkReference.DatabaseLinkNode.Terminals.Select(t => t.Token.Value)); var remoteObjectIdenrifier = OracleObjectIdentifier.Create(databaseLinkReference.OwnerNode, databaseLinkReference.ObjectNode, null); var columnNames = await CurrentQueryBlock.SemanticModel.DatabaseModel.GetRemoteTableColumnsAsync(databaseLinkIdentifier, remoteObjectIdenrifier, cancellationToken); expandedColumns.AddRange( columnNames.Select( n => new ColumnDescriptionItem { OwnerIdentifier = databaseLinkReference.FullyQualifiedObjectName, ColumnName = n.ToSimpleIdentifier() })); } foreach (var expandedColumn in expandedColumns.DistinctBy(c => c.ColumnNameLabel)) { _settingsModel.AddBooleanOption( new BooleanOption { OptionIdentifier = expandedColumn.ColumnNameLabel, DescriptionContent = BuildColumnOptionDescription(expandedColumn), Value = !expandedColumn.IsPseudocolumn && !expandedColumn.IsHidden && useDefaultSettings, Tag = expandedColumn }); } _settingsModel.Title = "Expand Asterisk"; _settingsModel.Heading = _settingsModel.Title; }
public CompilationErrorDataProvider(StatementBase statement, string currentSchema) : base(null) { _statement = statement; if (!OracleStatement.TryGetPlSqlUnitName(statement, out OracleObjectIdentifier objectIdentifier)) { return; } if (!objectIdentifier.HasOwner) { objectIdentifier = OracleObjectIdentifier.Create(currentSchema, objectIdentifier.Name); } _owner = objectIdentifier.NormalizedOwner.Trim('"'); _objectName = objectIdentifier.NormalizedName.Trim('"'); }
private static KeyValuePair <OracleConstraint, OracleObjectIdentifier> MapConstraintWithReferenceIdentifier(IDataRecord reader, IDictionary <OracleObjectIdentifier, OracleSchemaObject> allObjects) { var remoteConstraintIdentifier = OracleObjectIdentifier.Empty; var owner = QualifyStringObject(reader["OWNER"]); var ownerObjectFullyQualifiedName = OracleObjectIdentifier.Create(owner, QualifyStringObject(reader["TABLE_NAME"])); if (!allObjects.TryGetValue(ownerObjectFullyQualifiedName, out OracleSchemaObject ownerObject)) { return(new KeyValuePair <OracleConstraint, OracleObjectIdentifier>(null, remoteConstraintIdentifier)); } var rely = OracleReaderValueConvert.ToString(reader["RELY"]); var constraint = OracleObjectFactory.CreateConstraint((string)reader["CONSTRAINT_TYPE"], owner, QualifyStringObject(reader["CONSTRAINT_NAME"]), (string)reader["STATUS"] == "ENABLED", (string)reader["VALIDATED"] == "VALIDATED", (string)reader["DEFERRABLE"] == "DEFERRABLE", rely == "RELY"); var dataObject = (OracleDataObject)ownerObject; constraint.OwnerObject = dataObject; dataObject.Constraints.Add(constraint); if (constraint is OracleReferenceConstraint referenceConstraint) { var cascadeAction = DeleteRule.None; switch ((string)reader["DELETE_RULE"]) { case "CASCADE": cascadeAction = DeleteRule.Cascade; break; case "SET NULL": cascadeAction = DeleteRule.SetNull; break; case "NO ACTION": break; } referenceConstraint.DeleteRule = cascadeAction; remoteConstraintIdentifier = OracleObjectIdentifier.Create(QualifyStringObject(reader["R_OWNER"]), QualifyStringObject(reader["R_CONSTRAINT_NAME"])); } return(new KeyValuePair <OracleConstraint, OracleObjectIdentifier>(constraint, remoteConstraintIdentifier)); }
public async Task GetValue(WatchItem watchItem, CancellationToken cancellationToken) { SetupGetValueCommandParameters(watchItem.Name); await _debuggerSessionCommand.ExecuteNonQueryAsynchronous(cancellationToken); var result = (ValueInfoStatus)GetValueFromOracleDecimal(_debuggerSessionCommand.Parameters["RESULT"]); var value = GetValueFromOracleString(_debuggerSessionCommand.Parameters["VALUE"]); TraceLog.WriteLine($"Get value '{watchItem.Name}' result: {result}; value={value}"); if (result != ValueInfoStatus.ErrorIndexedTable) { watchItem.Value = result == ValueInfoStatus.ErrorNullValue ? "NULL" : FormatIfCursorValue(value); watchItem.ChildItems = null; return; } var indexes = await GetCollectionIndexes(OracleObjectIdentifier.Create(_runtimeInfo.SourceLocation.Owner, _runtimeInfo.SourceLocation.Name), watchItem.Name, cancellationToken); watchItem.Value = $"collection ({indexes.Count} items)"; var watchItems = new ObservableCollection <WatchItem>(); foreach (var index in indexes) { var collectionItemExpression = $"{watchItem.Name}({index.Value})"; SetupGetValueCommandParameters(collectionItemExpression); await _debuggerSessionCommand.ExecuteNonQueryAsynchronous(cancellationToken); var childItem = new WatchItem { Name = collectionItemExpression, Value = GetValueFromOracleString(_debuggerSessionCommand.Parameters["VALUE"]) }; watchItems.Add(childItem); } watchItem.ChildItems = watchItems; }
private static OracleSequence MapSequence(IDataRecord reader, IDictionary <OracleObjectIdentifier, OracleSchemaObject> allObjects) { var sequenceFullyQualifiedName = OracleObjectIdentifier.Create(QualifyStringObject(reader["SEQUENCE_OWNER"]), QualifyStringObject(reader["SEQUENCE_NAME"])); if (!allObjects.TryGetValue(sequenceFullyQualifiedName, out OracleSchemaObject sequenceObject)) { return(null); } var sequence = (OracleSequence)sequenceObject; sequence.CurrentValue = Convert.ToDecimal(reader["LAST_NUMBER"]); sequence.MinimumValue = Convert.ToDecimal(reader["MIN_VALUE"]); sequence.MaximumValue = Convert.ToDecimal(reader["MAX_VALUE"]); sequence.Increment = Convert.ToDecimal(reader["INCREMENT_BY"]); sequence.CacheSize = Convert.ToDecimal(reader["CACHE_SIZE"]); sequence.CanCycle = String.Equals((string)reader["CYCLE_FLAG"], "Y"); sequence.IsOrdered = String.Equals((string)reader["ORDER_FLAG"], "Y"); return(sequence); }
private static object MapSchemaObject(IDataRecord reader, IDictionary <OracleObjectIdentifier, OracleSchemaObject> allObjects) { var objectTypeIdentifer = OracleObjectIdentifier.Create(QualifyStringObject(reader["OWNER"]), QualifyStringObject(reader["OBJECT_NAME"])); var objectType = (string)reader["OBJECT_TYPE"]; var created = (DateTime)reader["CREATED"]; var isValid = (string)reader["STATUS"] == "VALID"; var lastDdl = (DateTime)reader["LAST_DDL_TIME"]; var isTemporary = String.Equals((string)reader["TEMPORARY"], "Y"); OracleSchemaObject schemaObject = null; switch (objectType) { case OracleObjectType.Table: if (allObjects.TryGetValue(objectTypeIdentifer, out schemaObject)) { goto case OracleObjectType.MaterializedView; } goto default; case OracleObjectType.MaterializedView: case OracleObjectType.Type: if (schemaObject == null && allObjects.TryGetValue(objectTypeIdentifer, out schemaObject)) { schemaObject.Created = created; schemaObject.IsTemporary = isTemporary; schemaObject.IsValid = isValid; schemaObject.LastDdl = lastDdl; } break; default: schemaObject = OracleObjectFactory.CreateSchemaObjectMetadata(objectType, objectTypeIdentifer.NormalizedOwner, objectTypeIdentifer.NormalizedName, isValid, created, lastDdl, isTemporary); AddObjectToDictionary(allObjects, schemaObject, schemaObject.Type); break; } return(schemaObject); }
private static OracleSchemaObject MapSchemaType(IDataRecord reader) { var owner = QualifyStringObject(reader["OWNER"]); OracleTypeBase schemaType; var typeType = (string)reader["TYPECODE"]; switch (typeType) { case OracleTypeBase.TypeCodeXml: schemaType = new OracleTypeObject().WithTypeCode(OracleTypeBase.TypeCodeXml); break; case OracleTypeBase.TypeCodeAnyData: schemaType = new OracleTypeObject().WithTypeCode(OracleTypeBase.TypeCodeAnyData); break; case OracleTypeBase.TypeCodeObject: schemaType = new OracleTypeObject(); break; case OracleTypeBase.TypeCodeCollection: schemaType = new OracleTypeCollection(); break; default: if (!String.IsNullOrEmpty(owner)) { throw new NotSupportedException($"Type '{typeType}' is not supported. "); } schemaType = new OracleTypeObject().WithTypeCode(typeType); break; } schemaType.FullyQualifiedName = OracleObjectIdentifier.Create(owner, QualifyStringObject(reader["TYPE_NAME"])); return(schemaType); }
private static OracleSchemaObject MapMaterializedView(IDataRecord reader) { var refreshModeRaw = (string)reader["REFRESH_MODE"]; var materializedView = new OracleMaterializedView { FullyQualifiedName = OracleObjectIdentifier.Create(QualifyStringObject(reader["OWNER"]), QualifyStringObject(reader["NAME"])), TableName = QualifyStringObject(reader["TABLE_NAME"]), IsPrebuilt = String.Equals((string)reader["OWNER"], "YES"), IsUpdatable = String.Equals((string)reader["OWNER"], "YES"), LastRefresh = OracleReaderValueConvert.ToDateTime(reader["LAST_REFRESH"]), Next = OracleReaderValueConvert.ToString(reader["NEXT"]), Query = (string)reader["QUERY"], RefreshGroup = QualifyStringObject(reader["REFRESH_GROUP"]), RefreshMethod = (string)reader["REFRESH_METHOD"], RefreshMode = String.Equals(refreshModeRaw, "DEMAND") ? MaterializedViewRefreshMode.OnDemand : MaterializedViewRefreshMode.OnCommit, RefreshType = MapMaterializedViewRefreshType((string)reader["TYPE"]), StartWith = OracleReaderValueConvert.ToDateTime(reader["START_WITH"]) }; return(materializedView); }
public override async Task MapReaderData(OracleDataReader reader, CancellationToken cancellationToken) { while (await reader.ReadAsynchronous(cancellationToken)) { var indexOwner = (string)reader["INDEX_OWNER"]; var indexName = (string)reader["INDEX_NAME"]; var indexIdentifier = OracleObjectIdentifier.Create(indexOwner, indexName); if (!_indexes.TryGetValue(indexIdentifier, out IndexDetailsModel indexModel)) { continue; } var indexColumn = new IndexColumnModel { ColumnName = (string)reader["COLUMN_NAME"], SortOrder = (string)reader["DESCEND"] == "ASC" ? SortOrder.Ascending : SortOrder.Descending }; indexModel.Columns.Add(indexColumn); } }
private static OracleSchemaObject MapSynonymTarget(IDataRecord reader, IDictionary <OracleObjectIdentifier, OracleSchemaObject> allObjects) { var synonymFullyQualifiedName = OracleObjectIdentifier.Create(QualifyStringObject(reader["OWNER"]), QualifyStringObject(reader["SYNONYM_NAME"])); if (!allObjects.TryGetValue(synonymFullyQualifiedName, out OracleSchemaObject synonymObject)) { return(null); } var objectFullyQualifiedName = OracleObjectIdentifier.Create(QualifyStringObject(reader["TABLE_OWNER"]), QualifyStringObject(reader["TABLE_NAME"])); if (!allObjects.TryGetValue(objectFullyQualifiedName, out OracleSchemaObject schemaObject)) { return(null); } var synonym = (OracleSynonym)synonymObject; synonym.SchemaObject = schemaObject; schemaObject.Synonyms.Add(synonym); return(synonymObject); }
protected override IReadOnlyList <OracleColumn> BuildPseudocolumns() { var pseudocolumns = new List <OracleColumn>(); var table = SchemaObject.GetTargetSchemaObject() as OracleTable; if (Type != ReferenceType.SchemaObject || table == null) { return(pseudocolumns.AsReadOnly()); } if (table.Organization == OrganizationType.Heap || table.Organization == OrganizationType.Index) { var rowIdPseudocolumn = new OracleColumn(true) { Name = RowIdNormalizedName, DataType = new OracleDataType { FullyQualifiedName = OracleObjectIdentifier.Create(null, table.Organization == OrganizationType.Index ? TerminalValues.UniversalRowId : TerminalValues.RowIdDataType) } }; pseudocolumns.Add(rowIdPseudocolumn); } if (FlashbackOption == FlashbackOption.None || FlashbackOption == FlashbackOption.AsOf) { var rowSystemChangeNumberPseudocolumn = new OracleColumn(true) { Name = "\"ORA_ROWSCN\"", DataType = OracleDataType.NumberType }; pseudocolumns.Add(rowSystemChangeNumberPseudocolumn); } else if ((FlashbackOption & FlashbackOption.Versions) == FlashbackOption.Versions) { var flashbackVersionColumns = new[] { new OracleColumn(true) { Name = "\"VERSIONS_STARTTIME\"", DataType = OracleDataType.CreateTimestampDataType(0) }, new OracleColumn(true) { Name = "\"VERSIONS_ENDTIME\"", DataType = OracleDataType.CreateTimestampDataType(0) }, new OracleColumn(true) { Name = "\"VERSIONS_STARTSCN\"", DataType = OracleDataType.NumberType }, new OracleColumn(true) { Name = "\"VERSIONS_ENDSCN\"", DataType = OracleDataType.NumberType }, new OracleColumn(true) { Name = "\"VERSIONS_OPERATION\"", DataType = new OracleDataType { FullyQualifiedName = OracleObjectIdentifier.Create(null, TerminalValues.Varchar2), Unit = DataUnit.Byte, Length = 1 } }, new OracleColumn(true) { Name = "\"VERSIONS_XID\"", DataType = new OracleDataType { FullyQualifiedName = OracleObjectIdentifier.Create(null, TerminalValues.Raw), Length = 8 } } }; pseudocolumns.AddRange(flashbackVersionColumns); } return(pseudocolumns.AsReadOnly()); }
protected override OracleObjectIdentifier BuildFullyQualifiedObjectName() { return(OracleObjectIdentifier.Create( AliasNode == null ? OwnerNode : null, Type == ReferenceType.InlineView ? null : ObjectNode, AliasNode)); }
private OracleColumn BuildColumnDescription() { var columnReference = IsDirectReference && ColumnReferences.Count == 1 ? ColumnReferences[0] : null; var columnDescription = columnReference?.ColumnDescription; _columnDescription = new OracleColumn { Name = ColumnName, Nullable = columnDescription == null, DataType = OracleDataType.Empty }; if (columnDescription != null) { _columnDescription.Nullable = columnDescription.Nullable; _columnDescription.DataType = columnDescription.DataType; _columnDescription.CharacterSize = columnDescription.CharacterSize; if (!_columnDescription.Nullable) { if (columnReference.ValidObjectReference is OracleDataObjectReference objectReference) { _columnDescription.Nullable = objectReference.IsOuterJoined; } } } if (IsAsterisk || RootNode.TerminalCount == 0) { return(_columnDescription); } var expressionNode = RootNode[0]; if (String.Equals(expressionNode.Id, NonTerminals.AliasedExpression)) { expressionNode = expressionNode[0]; } if (OracleDataType.TryResolveDataTypeFromExpression(expressionNode, _columnDescription) && !_columnDescription.DataType.IsDynamicCollection) { if (_columnDescription.DataType.FullyQualifiedName.Name.EndsWith("CHAR")) { _columnDescription.CharacterSize = _columnDescription.DataType.Length; } var isBuiltInDataType = _columnDescription.DataType.IsPrimitive && OracleDatabaseModelBase.BuiltInDataTypes.Any(t => String.Equals(t, _columnDescription.DataType.FullyQualifiedName.Name)); if (!isBuiltInDataType && SemanticModel.HasDatabaseModel) { var oracleType = SemanticModel.DatabaseModel.GetFirstSchemaObject <OracleTypeBase>(_columnDescription.DataType.FullyQualifiedName); if (oracleType == null) { _columnDescription.DataType = OracleDataType.Empty; } } } else if (columnDescription == null) { expressionNode = expressionNode.UnwrapIfNonChainedExpressionWithinParentheses(out bool isChainedExpression); if (!isChainedExpression) { var programReference = ProgramReferences.SingleOrDefault(r => r.RootNode == expressionNode); if (programReference == null) { var typeReference = TypeReferences.SingleOrDefault(r => r.RootNode == expressionNode); if (typeReference?.Metadata != null) { var x = typeReference.Metadata.ReturnParameter.CustomDataType; } } else if (programReference.Metadata != null) { if (programReference.Metadata.ReturnParameter == null) { if (programReference.Metadata.Identifier == OracleProgramIdentifier.IdentifierBuiltInProgramCoalesce) { } else if (programReference.Metadata.Identifier == OracleProgramIdentifier.IdentifierBuiltInProgramBinaryToNumber) { _columnDescription.DataType = OracleDataType.NumberType; } } else if (!String.IsNullOrEmpty(programReference.Metadata.ReturnParameter.DataType)) { if (programReference.Metadata.Identifier != OracleProgramIdentifier.IdentifierBuiltInProgramNvl) { _columnDescription.DataType = new OracleDataType { FullyQualifiedName = OracleObjectIdentifier.Create(null, programReference.Metadata.ReturnParameter.DataType) }; switch (programReference.Metadata.ReturnParameter.DataType) { case TerminalValues.Varchar: case TerminalValues.Varchar2: _columnDescription.CharacterSize = _columnDescription.DataType.Length = SemanticModel.DatabaseModel.MaximumVarcharLength; break; case TerminalValues.Raw: _columnDescription.DataType.Length = SemanticModel.DatabaseModel.MaximumRawLength; break; case TerminalValues.NVarchar: case TerminalValues.NVarchar2: _columnDescription.CharacterSize = _columnDescription.DataType.Length = SemanticModel.DatabaseModel.MaximumNVarcharLength; break; case TerminalValues.Timestamp: _columnDescription.DataType = OracleDataType.CreateTimestampDataType(9); break; case OracleDatabaseModelBase.BuiltInDataTypeTimestampWithTimeZone: _columnDescription.DataType = OracleDataType.CreateTimestampWithTimeZoneDataType(9); break; } } } } } } return(_columnDescription); }