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);
}
