subsonic 3.0.0.4

data/lib/T4 Templates/ActiveRecord/StoredProcedures.tt

@@ -0,0 +1,30 @@
+<#@ template language="C#v3.5" debug="False" hostspecific="True"  #>
+<#@ output extension=".cs" #>
+<#@ include file="SQLServer.ttinclude" #>
+<#
+    var sps = GetSPs(); 
+    if(sps.Count>0){ 
+#>  
+using System;
+using SubSonic;
+using SubSonic.Schema;
+using SubSonic.DataProviders;
+using System.Data;
+
+namespace <#=Namespace#>{
+	public partial class <#=DatabaseName#>DB{
+
+<#  foreach(var sp in sps){#>
+        public StoredProcedure <#=sp.CleanName#>(<#=sp.ArgList#>){
+            StoredProcedure sp=new StoredProcedure("<#=sp.Name#>",this.Provider);
+<#      foreach(var par in sp.Parameters){#>
+            sp.Command.AddParameter("<#=par.Name#>",<#=par.CleanName#>,DbType.<#=par.DbType#>);
+<#      }#>
+            return sp;
+        }
+<#  }#>
+	
+	}
+	
+}
+<#  }#> 

data/lib/T4 Templates/ActiveRecord/Structs.tt

@@ -0,0 +1,67 @@
+<#@ template language="C#v3.5" debug="False" hostspecific="True"  #>
+<#@ output extension=".cs" #>
+<#@ include file="SQLServer.ttinclude" #>
+<#
+    var tables = LoadTables();
+#>
+using System;
+using SubSonic.Schema;
+using System.Collections.Generic;
+using SubSonic.DataProviders;
+using System.Data;
+
+namespace <#=Namespace#> {
+	
+<#  foreach(var tbl in tables){
+        if(!ExcludeTables.Contains(tbl.Name))
+        {
+#>
+        /// <summary>
+        /// Table: <#=tbl.Name#>
+        /// Primary Key: <#=tbl.PrimaryKey#>
+        /// </summary>
+
+        public class <#=tbl.CleanName#>Table: DatabaseTable {
+            
+            public <#=tbl.CleanName#>Table(IDataProvider provider):base("<#=tbl.Name#>",provider){
+                ClassName = "<#=tbl.ClassName#>";
+                SchemaName = "<#=tbl.Schema ?? ""#>";
+                
+<#          foreach(var col in tbl.Columns){#>
+
+                Columns.Add(new DatabaseColumn("<#=col.Name#>", this)
+                {
+	                IsPrimaryKey = <#=col.IsPK.ToString().ToLower()#>,
+	                DataType = DbType.<#=col.DbType.ToString()#>,
+	                IsNullable = <#=col.IsNullable.ToString().ToLower()#>,
+	                AutoIncrement = <#=col.AutoIncrement.ToString().ToLower()#>,
+	                IsForeignKey = <#=col.IsForeignKey.ToString().ToLower()#>,
+	                MaxLength = <#=col.MaxLength#>
+                });
+<#          }#>                    
+                
+                
+            }
+
+<#          foreach(var col in tbl.Columns){#>
+            public IColumn <#=col.CleanName#>{
+                get{
+                    return this.GetColumn("<#=col.Name#>");
+                }
+            }
+				
+   			public static string <#= col.CleanName #>Column{
+			      get{
+        			return "<#= col.Name #>";
+      			}
+		    }
+            
+<#          }#>                    
+        }
+        
+<#    
+        }
+        
+    }
+#>
+}

data/lib/T4 Templates/LinqTemplates/Classes.tt

@@ -0,0 +1,117 @@
+<#@ template language="C#v3.5" debug="False" hostspecific="True"  #>
+<#@ output extension=".cs" #>
+<#@ include file="SQLServer.ttinclude" #>
+<#
+    var tables = LoadTables();
+#>
+using System;
+using System.ComponentModel;
+using System.Linq;
+
+namespace <#=Namespace#>
+{
+    
+    
+<#  foreach(Table tbl in tables){#>    
+    
+    /// <summary>
+    /// A class which represents the <#=tbl.Name#> table in the <#=DatabaseName#> Database.
+    /// This class is queryable through <#=DatabaseName#>DB.<#=tbl.ClassName#> 
+    /// </summary>
+
+	public partial class <#=tbl.ClassName#>: INotifyPropertyChanging, INotifyPropertyChanged
+	{
+        partial void OnLoaded();
+        partial void OnValidate(System.Data.Linq.ChangeAction action);
+        partial void OnCreated();
+	    
+	    public <#=tbl.ClassName#>(){
+	        OnCreated();
+	    }
+	    
+	    #region Properties
+	    
+<#      foreach(var col in tbl.Columns){
+			if (tbl.ClassName == col.CleanName)
+			{
+				col.CleanName += "X";
+			}
+#>
+        partial void On<#=col.CleanName#>Changing(<#=col.SysType#><#=CheckNullable(col)#> value);
+        partial void On<#=col.CleanName#>Changed();
+		
+		private <#=col.SysType#><#=CheckNullable(col)#> _<#=col.CleanName#>;
+		public <#=col.SysType#><#=CheckNullable(col)#> <#=col.CleanName#> { 
+		    get{
+		        return _<#=col.CleanName#>;
+		    } 
+		    set{
+		        this.On<#=col.CleanName#>Changing(value);
+                this.SendPropertyChanging();
+                this._<#=col.CleanName#> = value;
+                this.SendPropertyChanged("<#=col.CleanName#>");
+                this.On<#=col.CleanName#>Changed();
+		    }
+		}
+		
+<#      }#>
+
+        #endregion
+
+        #region Foreign Keys
+<#
+        List<string> fkCreated = new List<string>();
+        foreach(FKTable fk in tbl.FKTables)
+        { 
+            
+            if(!ExcludeTables.Contains(fk.OtherTable)){
+                string propName=fk.OtherQueryable;
+                if(fkCreated.Contains(propName))
+                {
+                    propName=fk.OtherQueryable+fkCreated.Count.ToString();
+                }
+                
+                fkCreated.Add(fk.OtherQueryable);
+                    
+               
+#>
+        public IQueryable<<#=fk.OtherClass #>> <#=propName #>
+        {
+            get
+            {
+                  var db=new <#=Namespace #>.<#=DatabaseName#>DB();
+                  return from items in db.<#=fk.OtherQueryable #>
+                       where items.<#=fk.OtherColumn#> == _<#=fk.ThisColumn#>
+                       select items;
+            }
+        }
+
+<#
+            }
+        }
+            
+#>
+        #endregion
+
+
+        private static PropertyChangingEventArgs emptyChangingEventArgs = new PropertyChangingEventArgs(String.Empty);
+        public event PropertyChangingEventHandler PropertyChanging;
+        public event PropertyChangedEventHandler PropertyChanged;
+        protected virtual void SendPropertyChanging()
+        {
+            var handler = PropertyChanging;
+            if (handler != null)
+               handler(this, emptyChangingEventArgs);
+        }
+
+        protected virtual void SendPropertyChanged(String propertyName)
+        {
+            var handler = PropertyChanged;
+            if (handler != null)
+                handler(this, new PropertyChangedEventArgs(propertyName));
+        }
+
+	}
+	
+<#}#>
+}

data/lib/T4 Templates/LinqTemplates/Context.tt

@@ -0,0 +1,276 @@
+<#@ template language="C#v3.5" debug="False" hostspecific="True"  #>
+<#@ output extension=".cs" #>
+<#@ include file="SQLServer.ttinclude" #>
+<#
+    var tables = LoadTables();
+#>
+using System;
+using System.Data;
+using System.Linq;
+using System.Linq.Expressions;
+using SubSonic.DataProviders;
+using SubSonic.Extensions;
+using SubSonic.Linq.Structure;
+using SubSonic.Query;
+using SubSonic.Schema;
+using System.Data.Common;
+using System.Collections.Generic;
+
+namespace <#=Namespace#>
+{
+    public partial class <#=DatabaseName#>DB : IQuerySurface
+    {
+
+        public IDataProvider DataProvider;
+        public DbQueryProvider provider;
+        
+        public bool TestMode
+		{
+            get
+			{
+                return DataProvider.ConnectionString.Equals("test", StringComparison.InvariantCultureIgnoreCase);
+            }
+        }
+
+        public <#=DatabaseName#>DB() 
+        { 
+            DataProvider = ProviderFactory.GetProvider("<#=ConnectionStringName#>");
+            Init();
+        }
+
+        public <#=DatabaseName#>DB(string connectionStringName)
+        {
+            DataProvider = ProviderFactory.GetProvider(connectionStringName);
+            Init();
+        }
+
+		public <#=DatabaseName#>DB(string connectionString, string providerName)
+        {
+            DataProvider = ProviderFactory.GetProvider(connectionString,providerName);
+            Init();
+        }
+
+		public ITable FindByPrimaryKey(string pkName)
+        {
+            return DataProvider.Schema.Tables.SingleOrDefault(x => x.PrimaryKey.Name.Equals(pkName, StringComparison.InvariantCultureIgnoreCase));
+        }
+
+        public Query<T> GetQuery<T>()
+        {
+            return new Query<T>(provider);
+        }
+        
+        public ITable FindTable(string tableName)
+        {
+            return DataProvider.FindTable(tableName);
+        }
+               
+        public IDataProvider Provider
+        {
+            get { return DataProvider; }
+            set {DataProvider=value;}
+        }
+        
+        public DbQueryProvider QueryProvider
+        {
+            get { return provider; }
+        }
+        
+        BatchQuery _batch = null;
+        public void Queue<T>(IQueryable<T> qry)
+        {
+            if (_batch == null)
+                _batch = new BatchQuery(Provider, QueryProvider);
+            _batch.Queue(qry);
+        }
+
+        public void Queue(ISqlQuery qry)
+        {
+            if (_batch == null)
+                _batch = new BatchQuery(Provider, QueryProvider);
+            _batch.Queue(qry);
+        }
+
+        public void ExecuteTransaction(IList<DbCommand> commands)
+		{
+            if(!TestMode)
+			{
+                using(var connection = commands[0].Connection)
+				{
+                   if (connection.State == ConnectionState.Closed)
+                        connection.Open();
+                   
+                   using (var trans = connection.BeginTransaction()) 
+				   {
+                        foreach (var cmd in commands) 
+						{
+                            cmd.Transaction = trans;
+                            cmd.Connection = connection;
+                            cmd.ExecuteNonQuery();
+                        }
+                        trans.Commit();
+                    }
+                    connection.Close();
+                }
+            }
+        }
+
+        public IDataReader ExecuteBatch()
+        {
+            if (_batch == null)
+                throw new InvalidOperationException("There's nothing in the queue");
+            if(!TestMode)
+                return _batch.ExecuteReader();
+            return null;
+        }
+<# //################################################     IQueryable         ####################################### #>			
+<#  foreach(Table tbl in tables){
+        if(!ExcludeTables.Contains(tbl.Name))
+        {
+#>
+        public Query<<#=tbl.ClassName#>> <#=tbl.QueryableName#> { get; set; }
+<#
+        }
+    }
+#>
+
+<# //################################################ Aggregates and Queries ####################################### #>			
+
+        #region ' Aggregates and SubSonic Queries '
+        public Select SelectColumns(params string[] columns)
+        {
+            return new Select(DataProvider, columns);
+        }
+
+        public Select Select
+        {
+            get { return new Select(this.Provider); }
+        }
+
+        public Insert Insert
+		{
+            get { return new Insert(this.Provider); }
+        }
+
+        public Update<T> Update<T>() where T:new()
+		{
+            return new Update<T>(this.Provider);
+        }
+
+        public SqlQuery Delete<T>(Expression<Func<T,bool>> column) where T:new()
+        {
+            LambdaExpression lamda = column;
+            SqlQuery result = new Delete<T>(this.Provider);
+            result = result.From<T>();
+            result.Constraints=lamda.ParseConstraints().ToList();
+            return result;
+        }
+
+        public SqlQuery Max<T>(Expression<Func<T,object>> column)
+        {
+            LambdaExpression lamda = column;
+            string colName = lamda.ParseObjectValue();
+            string objectName = typeof(T).Name;
+            string tableName = DataProvider.FindTable(objectName).Name;
+            return new Select(DataProvider, new Aggregate(colName, AggregateFunction.Max)).From(tableName);
+        }
+
+        public SqlQuery Min<T>(Expression<Func<T,object>> column)
+        {
+            LambdaExpression lamda = column;
+            string colName = lamda.ParseObjectValue();
+            string objectName = typeof(T).Name;
+            string tableName = this.Provider.FindTable(objectName).Name;
+            return new Select(this.Provider, new Aggregate(colName, AggregateFunction.Min)).From(tableName);
+        }
+
+        public SqlQuery Sum<T>(Expression<Func<T,object>> column)
+        {
+            LambdaExpression lamda = column;
+            string colName = lamda.ParseObjectValue();
+            string objectName = typeof(T).Name;
+            string tableName = this.Provider.FindTable(objectName).Name;
+            return new Select(this.Provider, new Aggregate(colName, AggregateFunction.Sum)).From(tableName);
+        }
+
+        public SqlQuery Avg<T>(Expression<Func<T,object>> column)
+        {
+            LambdaExpression lamda = column;
+            string colName = lamda.ParseObjectValue();
+            string objectName = typeof(T).Name;
+            string tableName = this.Provider.FindTable(objectName).Name;
+            return new Select(this.Provider, new Aggregate(colName, AggregateFunction.Avg)).From(tableName);
+        }
+
+        public SqlQuery Count<T>(Expression<Func<T,object>> column)
+        {
+            LambdaExpression lamda = column;
+            string colName = lamda.ParseObjectValue();
+            string objectName = typeof(T).Name;
+            string tableName = this.Provider.FindTable(objectName).Name;
+            return new Select(this.Provider, new Aggregate(colName, AggregateFunction.Count)).From(tableName);
+        }
+
+        public SqlQuery Variance<T>(Expression<Func<T,object>> column)
+        {
+            LambdaExpression lamda = column;
+            string colName = lamda.ParseObjectValue();
+            string objectName = typeof(T).Name;
+            string tableName = this.Provider.FindTable(objectName).Name;
+            return new Select(this.Provider, new Aggregate(colName, AggregateFunction.Var)).From(tableName);
+        }
+
+        public SqlQuery StandardDeviation<T>(Expression<Func<T,object>> column)
+        {
+            LambdaExpression lamda = column;
+            string colName = lamda.ParseObjectValue();
+            string objectName = typeof(T).Name;
+            string tableName = this.Provider.FindTable(objectName).Name;
+            return new Select(this.Provider, new Aggregate(colName, AggregateFunction.StDev)).From(tableName);
+        }
+
+        #endregion
+
+        void Init()
+        {
+            provider = new DbQueryProvider(this.Provider);
+
+<#
+    //################################################ QUERIES ####################################### #>
+            #region ' Query Defs '
+<#
+    foreach(Table tbl in tables)
+    {
+        if(!ExcludeTables.Contains(tbl.Name))
+        {
+#>
+            <#=tbl.QueryableName#> = new Query<<#=tbl.ClassName#>>(provider);
+<#
+        }
+#>
+<#
+    }
+#>
+            #endregion
+
+<#//################################################ SCHEMAS ####################################### #>
+
+            #region ' Schemas '
+        	if(DataProvider.Schema.Tables.Count == 0)
+			{
+<#
+    foreach(Table tbl in tables)
+    {
+        if(!ExcludeTables.Contains(tbl.Name))
+        {
+#>
+            	DataProvider.Schema.Tables.Add(new <#=tbl.CleanName#>Table(DataProvider));
+<#
+        }
+    }
+#>
+            }
+            #endregion
+        }
+    }
+}