/// <summary>
/// Opens a new <see cref="QuickBloxSession"/>.
/// </summary>
/// <returns>Returns QuickBlox session object for communicating with the QuickBlox' REST Api.</returns>
public QuickBloxSession OpenSession()
{
lock (locker)
{
if (currentSession == null || currentSession.Expiration <= DateTime.UtcNow)
{
var session = String.IsNullOrWhiteSpace(configuration.Username) || String.IsNullOrWhiteSpace(configuration.UserPassword)
? OpenAnonymousSession()
: OpenUserSession();
session.SessionFactory = this;
Provider = new QuickBloxQueryProvider(configuration.Endpoint, session.Token);
currentSession = new SessionWrap(session);
}
}
return currentSession.Session;
}
/// <summary>
/// Translates a LINQ expression into an actionable Pig query.
/// </summary>
/// <param name="provider">The QueryProvider.</param>
/// <param name="expression">The LINQ expression.</param>
/// <returns>A TranslatedQuery.</returns>
public static TranslatedQuery Translate(QueryProvider provider, Expression expression)
{
Type sourceType = GetSourceType(expression);
var projection = expression as ProjectionExpression;
if (projection == null)
{
expression = PartialEvaluator.Evaluate(expression);
expression = QueryBinder.Bind(provider, expression);
expression = AggregateRewriter.Rewrite(expression);
//expression = OrderByRewriter.Rewrite(expression);
expression = UnusedColumnRemover.Remove(expression);
expression = RedundantSubqueryRemover.Remove(expression);
projection = (ProjectionExpression) expression;
}
// assume for now it is a SelectQuery
var selectQuery = new SelectQuery(provider.Source, sourceType);
selectQuery.Translate(projection);
return selectQuery;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="MapperProvider">The mapper provider.</param>
/// <param name="QueryProvider">The query provider.</param>
/// <param name="SchemaProvider">The schema provider.</param>
/// <param name="SourceProvider">The source provider.</param>
/// <param name="Databases">The databases.</param>
public ORMManager(Mapper.Manager MapperProvider,
QueryProvider.Manager QueryProvider,
Schema.Manager SchemaProvider,
SourceProvider.Manager SourceProvider,
IEnumerable<IDatabase> Databases)
{
Contract.Requires<ArgumentNullException>(MapperProvider != null, "MapperProvider");
Contract.Requires<ArgumentNullException>(QueryProvider != null, "QueryProvider");
Contract.Requires<ArgumentNullException>(SchemaProvider != null, "SchemaProvider");
Contract.Requires<ArgumentNullException>(SourceProvider != null, "SourceProvider");
Contract.Requires<ArgumentNullException>(Databases != null, "Databases");
this.Mappings = new ListMapping<IDatabase, IMapping>();
this.MapperProvider = MapperProvider;
this.QueryProvider = QueryProvider;
this.SchemaProvider = SchemaProvider;
this.SourceProvider = SourceProvider;
SetupMappings(Databases);
foreach (IDatabase Database in Mappings.Keys.Where(x => x.Update))
{
this.SchemaProvider.Setup(Mappings, QueryProvider, Database, SourceProvider.GetSource(Database.GetType()));
}
}
/// <summary>
/// Generates a batch that will update the data from the object
/// </summary>
/// <param name="Object">Object to update</param>
/// <returns>Batch with the appropriate commands</returns>
public IBatch Update(T Object)
{
return(QueryProvider.Batch(Source));
}
/// <summary>
/// Generates a batch that will get the number of pages for a given page size given the
/// parameters specified
/// </summary>
/// <param name="Parameters">Parameters</param>
/// <param name="PageSize">Page size</param>
/// <returns>Batch with the appropriate commands</returns>
public IBatch PageCount(int PageSize, params IParameter[] Parameters)
{
return(QueryProvider.Batch(Source));
}
/// <summary>
/// Saves items to the joining table for the property
/// </summary>
/// <param name="Property">Property</param>
/// <param name="Object">Object</param>
/// <typeparam name="P">Property type</typeparam>
/// <typeparam name="ItemType">Item type</typeparam>
/// <returns>The batch with the appropriate commands</returns>
public IBatch JoinsSave <P, ItemType>(IProperty <T, P> Property, T Object)
{
return(QueryProvider.Batch(Source));
}
/// <summary>
/// Generates a batch that will insert the data from the object
/// </summary>
/// <param name="Object">Object to insert</param>
/// <returns>Batch with the appropriate commands</returns>
public IBatch Insert(T Object)
{
return(QueryProvider.Batch(Source));
}
protected override void Init()
{
base.Init();
if (_contentTypeProvider == null)
_contentTypeProvider = new ContentTypeProvider();
if (_queryProvider == null)
_queryProvider = new QueryProvider();
}
public override void Setup()
{
base.Setup();
_expression = Source.AsQueryable<AttributedFakeData>().Expression;
_provider = new FakeQueryProvider(Source, _fakeResults);
}
public ISearchTypeQueryBuilder <T> Matching(Expression <Func <QueryFields, bool> > predicate, QueryOptions queryOptions)
{
return(new SearchTypeQueryBuilder <T>(this, this.entities, QueryProvider.Get(predicate, queryOptions)));
}
/// <summary>
/// Initializes a new instance of the <see cref="Repository"/> class.
/// </summary>
/// <param name="integrationProxy">The integration proxy.</param>
/// <param name="provider">The query provider proxy.</param>
public Repository(IIntegrationProxy integrationProxy, QueryProvider provider)
{
_proxy = integrationProxy;
_provider = provider;
}
/// <summary>
/// Initializes a new instance of the <see cref="Repository"/> class.
/// </summary>
/// <param name="integrationProxy">The integration proxy.</param>
public Repository(IIntegrationProxy integrationProxy)
{
_proxy = integrationProxy;
_provider = new ApiQueryProvider(_proxy);
}
/// <summary>
/// Initializes a new instance of the <see cref="Repository"/> class.
/// </summary>
/// <param name="oauthSession">The oauth session.</param>
public Repository(IOAuthSession oauthSession)
{
_proxy = (new IntegrationProxy(oauthSession));
_provider = new ApiQueryProvider(_proxy);
}
public virtual Task <int> ExecuteAsync()
{
return(QueryProvider.ExecuteNonQueryAsync(BuildQuery()));
}
internal OrderedQuery(QueryProvider provider, object?providerState, Expression <Func <T, bool> >?predicate, long skip, long take, OrderNode order, bool reversed)
: base(provider, providerState, predicate, skip, take)
{
Tail = order ?? throw new ArgumentNullException(nameof(order));
Reversed = reversed;
}
/// <summary>
/// Initializes the controls.
/// </summary>
private void SetupControl()
{
DataClassInfo newClass = null;
mQueryName = GetString("queryedit.newquery");
// If the existing query is being edited
if (QueryID > 0)
{
// Get information on existing query
Query = QueryProvider.GetQuery(QueryID);
if (Query != null)
{
ClassName = DataClassInfoProvider.GetClassName(Query.QueryClassId);
QueryName = Query.QueryName;
if (!RequestHelper.IsPostBack())
{
// Fills form with the existing query information
LoadValues();
txtQueryText.Focus();
}
}
}
// New query is being created
else if (ClassID > 0)
{
newClass = DataClassInfoProvider.GetDataClass(ClassID);
ClassName = newClass.ClassName;
if (!RequestHelper.IsPostBack())
{
ucSelectString.Value = newClass.ClassConnectionString;
}
txtQueryName.Focus();
}
plcLoadGeneration.Visible = SettingsKeyProvider.DevelopmentMode;
// Ensure generate button and custom checkbox for default queries
if (QueryProvider.IsSystemQuery(QueryName))
{
btnGenerate.Visible = true;
plcIsCustom.Visible = true;
}
// For new query with hidden Is custom checkbox
if ((newClass != null) && !plcIsCustom.Visible)
{
// Do not set queries as custom in development mode except document types and custom tables
chckIsCustom.Checked = !SettingsKeyProvider.DevelopmentMode || newClass.ClassIsDocumentType || newClass.ClassIsCustomTable;
}
// Initialize the validator
RequiredFieldValidatorQueryName.ErrorMessage = GetString("queryedit.erroremptyqueryname");
if (ShowHelp)
{
DisplayHelperTable();
}
// Filter available only when creating new query in dialog mode
plcDocTypeFilter.Visible = filter.Visible = DialogMode && !EditMode;
// Set filter preselection
if (plcDocTypeFilter.Visible)
{
filter.SelectedValue = QueryHelper.GetString("selectedvalue", null);
filter.FilterMode = SettingsObjectType.QUERY;
}
// Hide header actions when creating new query in dialog mode
mCurrentMaster.HeaderActions.Parent.Visible = (!DialogMode || EditMode) && Visible;
txtQueryName.Enabled = !DialogMode || !EditMode;
// Set dialog's content panel css class
if (DialogMode)
{
if (EditMode)
{
mCurrentMaster.PanelContent.CssClass = "PageContent";
}
else
{
pnlContainer.CssClass = "PageContent";
}
}
}
public SalesforceQuery(QueryProvider provider, Expression expression) : base(provider, expression)
{
}
/// <summary>
/// Sets up the specified database schema
/// </summary>
/// <param name="Mappings">The mappings.</param>
/// <param name="Database">The database.</param>
/// <param name="QueryProvider">The query provider.</param>
public void Setup(ListMapping<IDatabase, IMapping> Mappings, IDatabase Database, QueryProvider.Manager QueryProvider)
{
ISourceInfo TempSource = SourceProvider.GetSource(Database.Name);
var TempDatabase = new Schema.Default.Database.Database(Regex.Match(TempSource.Connection, "Initial Catalog=(.*?;)").Value.Replace("Initial Catalog=", "").Replace(";", ""));
SetupTables(Mappings, Database, TempDatabase);
SetupJoiningTables(Mappings, Database, TempDatabase);
SetupAuditTables(Database, TempDatabase);
foreach (ITable Table in TempDatabase.Tables)
{
Table.SetupForeignKeys();
}
List<string> Commands = GenerateSchema(TempDatabase, SourceProvider.GetSource(Database.Name)).ToList();
IBatch Batch = QueryProvider.Batch(SourceProvider.GetSource(Database.Name));
for (int x = 0; x < Commands.Count; ++x)
{
if (Commands[x].ToUpperInvariant().Contains("CREATE DATABASE"))
{
QueryProvider.Batch(SourceProvider.GetSource(Regex.Replace(SourceProvider.GetSource(Database.Name).Connection, "Initial Catalog=(.*?;)", ""))).AddCommand(null, null, CommandType.Text, Commands[x]).Execute();
}
else if (Commands[x].Contains("CREATE TRIGGER") || Commands[x].Contains("CREATE FUNCTION"))
{
if (Batch.CommandCount > 0)
{
Batch.Execute();
Batch = QueryProvider.Batch(SourceProvider.GetSource(Database.Name));
}
Batch.AddCommand(null, null, CommandType.Text, Commands[x]);
if (x < Commands.Count - 1)
{
Batch.Execute();
Batch = QueryProvider.Batch(SourceProvider.GetSource(Database.Name));
}
}
else
{
Batch.AddCommand(null, null, CommandType.Text, Commands[x]);
}
}
Batch.Execute();
}
/// <summary>
/// Initialize the DBSet properties by type reflection.
/// </summary>
private void InitializeDbSets()
{
var type = GetType();
var dbSetType = typeof(DbSet<>);
var properties = type.GetRuntimeProperties()
.Where(p => (p.PropertyType.GetInterfaces().Count() > 0 &&
p.PropertyType.GetInterfaces().Any(i => CheckPropertyInfoImplementsIDbSet(i)))
|| (CheckPropertyInfoImplementsIDbSet(p.PropertyType)))
.Select(p => new
{
p,
p.PropertyType
});
if (properties != null && properties.Any())
{
foreach(var property in properties)
{
var queryProvider = new QueryProvider(_queryExecutor, _mappingRuleTranslator, _queryTracker);
var genericArguments = property.p.PropertyType.GetGenericArguments();
var constructedType = dbSetType.MakeGenericType(genericArguments);
var dbSet = Activator.CreateInstance(constructedType, new[] { queryProvider });
property.p.SetValue(this, dbSet, null);
}
}
}
/// <summary>
/// Sets up the specified database schema
/// </summary>
/// <param name="Mappings">The mappings.</param>
/// <param name="Database">The database.</param>
/// <param name="QueryProvider">The query provider.</param>
public void Setup(ListMapping<IDatabase, IMapping> Mappings, IDatabase Database, QueryProvider.Manager QueryProvider)
{
}
public UpdateProvider(MetadataInfo data, MetadataProvider metadata, QueryProvider query)
{
_data = data;
_metadata = metadata;
_query = query;
}
public UIAddSource(QueryProvider queryProvider)
{
this.queryProvider = queryProvider;
InitializeComponent();
InitialiseFormControls();
}
/// <summary>
/// Gets the where condition for the selected object type.
/// </summary>
/// <param name="selectedObjectType">Selected object type</param>
public string GetWhereCondition(string selectedObjectType)
{
if (Object != null)
{
string where = null;
translationSiteName = TranslationHelper.NO_SITE;
if (RelatedObject != null)
{
// Get the site name
int selectedSiteId = 0;
if ((RelatedObject.SiteIDColumn != TypeInfo.COLUMN_NAME_UNKNOWN) && (CMSObjectHelper.GetSiteBindingObject(RelatedObject) == null))
{
if (siteSelector.DropDownSingleSelect.Items.Count == 0)
{
siteSelector.Value = CMSContext.CurrentSiteID;
}
if (this.siteSelector.HasData)
{
// Set the site name for registration
selectedSiteId = ValidationHelper.GetInteger(this.siteSelector.Value, 0);
if (selectedSiteId < 0)
{
// Automatic site name in case of
translationSiteName = TranslationHelper.AUTO_SITENAME;
}
else
{
string siteWhere = QueryProvider.GetQuery(RelatedObject.ObjectType + ".selectall", RelatedObject.IDColumn, SqlHelperClass.GetSiteIDWhereCondition(RelatedObject.SiteIDColumn, selectedSiteId), null, 0);
// Where condition for the left object
string rightWhere = ObjectRelationshipInfoProvider.GetWhereCondition(ObjectID, ObjectType, 0, false, true, selectedObjectType);
rightWhere += " AND RelationshipLeftObjectID IN (" + siteWhere + ")";
// Where condition for the left object
string leftWhere = ObjectRelationshipInfoProvider.GetWhereCondition(ObjectID, ObjectType, 0, true, false, selectedObjectType);
leftWhere += " AND RelationshipRightObjectID IN (" + siteWhere + ")";
// --- Add site conditions here
where = SqlHelperClass.AddWhereCondition(leftWhere, rightWhere, "OR");
}
}
}
showTypes = false;
}
else
{
showTypes = true;
}
if (String.IsNullOrEmpty(where))
{
// Get using regular where
where = ObjectRelationshipInfoProvider.GetWhereCondition(ObjectID, ObjectType, 0, true, true, selectedObjectType);
}
return(where);
}
return(null);
}
/// <summary>
/// Deletes items from the joining table for the property
/// </summary>
/// <param name="Property">Property</param>
/// <param name="Object">Object</param>
/// <typeparam name="P">Property type</typeparam>
/// <returns>The batch with the appropriate commands</returns>
public IBatch JoinsDelete <P>(IProperty <T, P> Property, T Object)
{
return(QueryProvider.Batch(Source));
}
internal Query(QueryProvider provider, object?providerState) : this(provider, providerState, null, 0, -1)
{
}
/// <summary>
/// Generates a batch that will get the specific property for the object
/// </summary>
/// <typeparam name="P">Property type</typeparam>
/// <param name="Object">Object to get the property for</param>
/// <param name="Property">Property to get</param>
/// <returns>Batch with the appropriate commands</returns>
public IBatch LoadProperty <P>(T Object, IProperty Property)
{
return(QueryProvider.Batch(Source));
}
protected virtual Query <T> Wrap(QueryProvider provider, object?providerState, Expression <Func <T, bool> >?predicate, long skip, long take) => new(provider, providerState, predicate, skip, take);
/// <summary>
/// Saves the object to the source
/// </summary>
/// <typeparam name="PrimaryKeyType">Primary key type</typeparam>
/// <param name="Object">Object to save</param>
public IBatch Save <PrimaryKeyType>(T Object)
{
return(QueryProvider.Batch(Source));
}
static int Count(QueryProvider provider, string?prefix) =>
provider.Read <int>(1.LocalIdFor($@"
|select count(productid)
| from product
| where code {prefix:=*}"));
protected void Page_Load(object sender, EventArgs e)
{
Query query = null;
if (PersistentEditedObject == null)
{
// Get query depending on whether this was invoked from a dialog or site manager
if (mDialogMode)
{
string queryName = QueryHelper.GetString("name", string.Empty);
if (queryName != string.Empty)
{
PersistentEditedObject = QueryProvider.GetQuery(queryName, false);
}
}
else
{
int queryId = QueryHelper.GetInteger("queryid", 0);
if (queryId > 0)
{
PersistentEditedObject = QueryProvider.GetQuery(queryId);
}
}
}
query = PersistentEditedObject as Query;
// Initialize breadcrumbs and tabs
if (query != null)
{
SetEditedObject(query, null);
if (!mDialogMode)
{
InitBreadcrumbs(2);
SetBreadcrumb(0, GetString("DocumentType_Edit_Query_Edit.Queries"), ResolveUrl("~/CMSModules/DocumentTypes/Pages/Development/DocumentType_Edit_Query_List.aspx?documenttypeid=" + query.QueryClassId), "_parent", null);
SetBreadcrumb(1, query.QueryName, null, null, null);
}
else
{
SetTitle("Objects/CMS_Query/object.png", GetString("query.edit"), null, "helpTopic");
string selector = QueryHelper.GetString("selectorid", string.Empty);
if (!string.IsNullOrEmpty(selector) && RequestHelper.IsPostBack())
{
ScriptHelper.RegisterWOpenerScript(this);
// Add selector refresh
string script =
string.Format(@"if (wopener && wopener.US_SelectNewValue_{0}) {{ wopener.US_SelectNewValue_{0}('{1}'); }}",
selector, query.QueryFullName);
ScriptHelper.RegisterStartupScript(this, GetType(), "UpdateSelector", script, true);
}
}
string helpTopic = "newedit_query";
// Set page title
DataClassInfo classObj = DataClassInfoProvider.GetDataClass(query.QueryClassId);
if ((classObj != null) && classObj.ClassIsCustomTable)
{
helpTopic = "customtable_edit_newedit_query";
}
SetHelp(helpTopic, "helpTopic");
// Set tabs number and ensure additional tab
InitTabs("q_edit_content");
string url = "~/CMSModules/DocumentTypes/Pages/Development/DocumentType_Edit_Query_Edit.aspx" + URLHelper.Url.Query;
url = URLHelper.RemoveParameterFromUrl(url, "saved");
if (mDialogMode)
{
url = URLHelper.AddParameterToUrl(url, "name", query.QueryFullName);
}
else
{
url = URLHelper.AddParameterToUrl(url, "queryid", query.QueryId.ToString());
}
SetTab(0, GetString("general.general"), ResolveUrl(url), "SetHelpTopic('helpTopic', '" + helpTopic + "');");
}
}
static async Task <int> CountAsync(QueryProvider provider, string?prefix) =>
await provider.ReadAsync <int>(1.LocalIdFor($@"
|select count(productid)
| from product
| where code {prefix:=*}"))
.ConfigureAwait(false);
protected override Query <T> Wrap(QueryProvider provider, object?providerState, Expression <Func <T, bool> >?predicate, long skip, long take) => new OrderedQuery <T>(provider, providerState, predicate, skip, take, Tail, Reversed);
public ISearchTypeQueryBuilder <T> Matching(Expression <Func <QueryFields, bool> > predicate)
{
return(new SearchTypeQueryBuilder(this.searchBuilder, this.entities, QueryProvider.Get(predicate)));
}
internal FileSystemContext(QueryProvider provider, Expression expression) : base(provider, expression)
{
}
public AppInsightsTable(ApplicationInsightsClient client, string name)
{
QueryName = name;
Provider = new QueryProvider(client);
Expression = Expression.Constant(this);
}
/// <summary>
/// Sets up the specified databases
/// </summary>
/// <param name="Mappings">The mappings.</param>
/// <param name="QueryProvider">The query provider.</param>
/// <param name="Database">The database.</param>
/// <param name="Source">The source.</param>
/// <param name="Structure">The structure.</param>
public void Setup(ListMapping<IDatabase, IMapping> Mappings, QueryProvider.Manager QueryProvider, IDatabase Database, ISourceInfo Source, Graph<IMapping> Structure)
{
Contract.Requires<NullReferenceException>(Mappings != null, "Mappings");
SchemaGenerators[Source.SourceType].Setup(Mappings, Database, QueryProvider, Structure);
}
public Query(QueryProvider queryProvider)
{
this.Provider = queryProvider;
this.Expression = Expression.Constant(this);
}
public void it_exposes_the_ISource()
{
// Act
var provider = new QueryProvider(Source);
// Assert
Assert.AreSame(Source, provider.Source);
}
public Query(QueryProvider queryProvider, Expression expression)
{
this.Provider = queryProvider;
this.Expression = expression;
}
public override void Setup()
{
base.Setup();
_expression = Source.AsQueryable<FakeData>().Expression;
_provider = new QueryProvider(Source);
}
/// <summary>
/// Saves items to the joining table for the property
/// </summary>
/// <param name="Property">Property</param>
/// <param name="Object">Object</param>
/// <typeparam name="P">Property type</typeparam>
/// <typeparam name="ItemType">Item type</typeparam>
/// <returns>The batch with the appropriate commands</returns>
public IBatch JoinsSave <P, ItemType>(IProperty <T, P> Property, T Object)
{
var ReturnValue = QueryProvider.Batch(Source);
if (Object == null)
{
return(ReturnValue);
}
if (Property as IManyToOne != null)
{
var Item = (P)Property.GetValue(Object);
if (Item == null)
{
return(ReturnValue);
}
var CurrentID = ((IProperty <T>)Mapping.IDProperties.FirstOrDefault()).GetValue(Object);
IMapping ForeignMapping = Property.ForeignMapping;
var ForeignID = ForeignMapping.IDProperties.FirstOrDefault().GetValue(Item);
string Parameters = "";
object[] Values = new object[2];
if (string.Compare(Mapping.TableName, ForeignMapping.TableName, StringComparison.InvariantCulture) == 0)
{
Parameters = Mapping.TableName + Mapping.IDProperties.FirstOrDefault().FieldName + "," + ForeignMapping.TableName + ForeignMapping.IDProperties.FirstOrDefault().FieldName + "2";
Values[1] = CurrentID;
Values[0] = ForeignID;
}
else if (string.Compare(Mapping.TableName, ForeignMapping.TableName, StringComparison.InvariantCulture) <= 0)
{
Parameters = Mapping.TableName + Mapping.IDProperties.FirstOrDefault().FieldName + "," + ForeignMapping.TableName + ForeignMapping.IDProperties.FirstOrDefault().FieldName;
Values[0] = CurrentID;
Values[1] = ForeignID;
}
else
{
Parameters = ForeignMapping.TableName + ForeignMapping.IDProperties.FirstOrDefault().FieldName + "," + Mapping.TableName + Mapping.IDProperties.FirstOrDefault().FieldName;
Values[1] = CurrentID;
Values[0] = ForeignID;
}
ReturnValue.AddCommand(null, Object,
"INSERT INTO " + Property.TableName + "(" + Parameters + ") VALUES (@0,@1)",
CommandType.Text,
Values);
return(ReturnValue);
}
var List = (IEnumerable <ItemType>)Property.GetValue(Object);
if (List == null)
{
return(ReturnValue);
}
foreach (ItemType Item in List)
{
if (Item != null)
{
var CurrentID = Mapping.IDProperties.FirstOrDefault().GetValue(Object);
IMapping ForeignMapping = Property.ForeignMapping;
var ForeignID = ForeignMapping.IDProperties.FirstOrDefault().GetValue(Item);
string Parameters = "";
object[] Values = new object[2];
if (string.Compare(Mapping.TableName, ForeignMapping.TableName, StringComparison.InvariantCulture) < 0)
{
Parameters = Mapping.TableName + Mapping.IDProperties.FirstOrDefault().FieldName + "," + ForeignMapping.TableName + ForeignMapping.IDProperties.FirstOrDefault().FieldName;
Values[0] = CurrentID;
Values[1] = ForeignID;
}
else if (string.Compare(Mapping.TableName, ForeignMapping.TableName, StringComparison.InvariantCulture) == 0)
{
Parameters = Mapping.TableName + Mapping.IDProperties.FirstOrDefault().FieldName + "," + ForeignMapping.TableName + ForeignMapping.IDProperties.FirstOrDefault().FieldName + "2";
Values[0] = CurrentID;
Values[1] = ForeignID;
}
else
{
Parameters = ForeignMapping.TableName + ForeignMapping.IDProperties.FirstOrDefault().FieldName + "," + Mapping.TableName + Mapping.IDProperties.FirstOrDefault().FieldName;
Values[1] = CurrentID;
Values[0] = ForeignID;
}
ReturnValue.AddCommand(null,
Object,
"INSERT INTO " + Property.TableName + "(" + Parameters + ") VALUES (@0,@1)",
CommandType.Text,
Values);
}
}
return(ReturnValue);
}
/// <summary>
/// Constructor
/// </summary>
public LDAPSchemaGenerator(QueryProvider.Manager Provider, SourceProvider.Manager SourceProvider)
{
this.Provider = Provider;
this.SourceProvider = SourceProvider;
}
/// <summary>
/// Sets up the specified database schema
/// </summary>
/// <param name="Mappings">The mappings.</param>
/// <param name="Database">The database.</param>
/// <param name="QueryProvider">The query provider.</param>
/// <param name="Structure">The structure.</param>
public void Setup(ListMapping<IDatabase, IMapping> Mappings, IDatabase Database, QueryProvider.Manager QueryProvider, Graph<IMapping> Structure)
{
}
