using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
namespace Data1.Entity
{

public class CompareCollection : IComparer
{
public CompareCollection() { }

private string sortField;
private string filterField;
private string sortOrder;

public string SortField
{
get
{
return sortField;
}
set
{
sortField = value;
}
}
public string FilterField
{
get
{
return filterField;
}
set
{
filterField = value;
}
}
// ASC or DESC ways to order collection

public string SortOrder
{
get
{
return sortOrder;
}
set
{
sortOrder = value;
}
}

public int Compare(object x, object y)
{
Cumulative xCumulative = (Cumulative)x;
Cumulative yCumulative = (Cumulative)y;

switch (SortField)
{
// compare CumulativeDesc column

case (“RawData”):
if (xCumulative.RawData.CompareTo(yCumulative.RawData) == -1)
return (SortOrder == “ASC”) ? -1 : 1;
else if (xCumulative.RawData.CompareTo(yCumulative.RawData) == 1)
return (SortOrder == “ASC”) ? 1 : -1;
else
return 0;

// compare MinLvl column

case (“ActiveData”):
if (xCumulative.ActiveData < yCumulative.ActiveData)
return (SortOrder == “ASC”) ? -1 : 1;
else if (xCumulative.ActiveData > yCumulative.ActiveData)
return (SortOrder == “ASC”) ? 1 : -1;
else
return 0;

// compare MaxLvl column

case (“PassiveData”):
if (xCumulative.PassiveData < yCumulative.PassiveData)
return (SortOrder == “ASC”) ? -1 : 1;
else if (xCumulative.PassiveData > yCumulative.PassiveData)
return (SortOrder == “ASC”) ? 1 : -1;
else
return 0;

// compare CumulativeId column by default

default:
if (xCumulative.DeadData < yCumulative.DeadData)
return (SortOrder == “ASC”) ? -1 : 1;
else if (xCumulative.DeadData > yCumulative.DeadData)
return (SortOrder == “ASC”) ? 1 : -1;
else
return 0;
}
}

public int Filter(object x)
{
Cumulative xCumulative = (Cumulative)x;
//    Cumulative yCumulative = (Cumulative)y;

switch (FilterField)
{
// compare CumulativeDesc column

case (“RawData”):
if (xCumulative.RawData.CompareTo(yCumulative.RawData) == -1)
return (SortOrder == “ASC”) ? -1 : 1;
else if (xCumulative.RawData.CompareTo(yCumulative.RawData) == 1)
return (SortOrder == “ASC”) ? 1 : -1;
else
return 0;

// compare MinLvl column

case (“ActiveData”):
if (xCumulative.ActiveData < yCumulative.ActiveData)
return (SortOrder == “ASC”) ? -1 : 1;
else if (xCumulative.ActiveData > yCumulative.ActiveData)
return (SortOrder == “ASC”) ? 1 : -1;
else
return 0;

// compare MaxLvl column

case (“PassiveData”):
if (xCumulative.PassiveData < yCumulative.PassiveData)
return (SortOrder == “ASC”) ? -1 : 1;
else if (xCumulative.PassiveData > yCumulative.PassiveData)
return (SortOrder == “ASC”) ? 1 : -1;
else
return 0;

// compare CumulativeId column by default

default:
if (xCumulative.DeadData < yCumulative.DeadData)
return (SortOrder == “ASC”) ? -1 : 1;
else if (xCumulative.DeadData > yCumulative.DeadData)
return (SortOrder == “ASC”) ? 1 : -1;
else
return 0;
}
}
}
}

/*********Cumulative class and collection for sorting in collection********/
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.SqlClient;
using System.Text;

namespace Data1.Entity
{
public class Cumulative
{
#region Fields
private Int32 userID;
private Int32 catId;
private string userName;
private string catName;
private Int32 rawData;
private Int32 activeData;
private Int32 passiveData;
private Int32 deadData;
private Int32 archiveData;
private Int32 assignedData;
private Int32 rawAdvertiser;
private Int32 activeAdvertiser;
private Int32 passiveAdvertiser;
private Int32 deadAdvertiser;

private Int32 activeOrder;
private Int32 pendingOrder;
private DateTime date;

#endregion

#region Properties
public Int32 UserID
{
get { return userID; }
set { userID = value; }
}
public Int32 CatId
{
get { return catId; }
set { catId = value; }
}
public string UserName
{
get { return userName; }
set { userName = value; }
}
public string CatName
{
get { return catName; }
set { catName = value; }
}
public Int32 RawData
{
get { return rawData; }
set { rawData = value; }
}
public Int32 ActiveData
{
get { return activeData; }
set { activeData = value; }
}
public Int32 PassiveData
{
get { return passiveData; }
set { passiveData = value; }
}
public Int32 DeadData
{
get { return deadData; }
set { deadData = value; }
}
public Int32 ArchiveData
{
get { return archiveData; }
set { archiveData = value; }
}
public Int32 AssignedData
{
get { return assignedData; }
set { assignedData = value; }
}
public Int32 RawAdvertiser
{
get { return rawAdvertiser; }
set { rawAdvertiser = value; }
}
public Int32 ActiveAdvertiser
{
get { return activeAdvertiser; }
set { activeAdvertiser = value; }
}
public Int32 PassiveAdvertiser
{
get { return passiveAdvertiser; }
set { passiveAdvertiser = value; }
}
public Int32 DeadAdvertiser
{
get { return deadAdvertiser; }
set { deadAdvertiser = value; }
}
public Int32 ActiveOrder
{
get { return activeOrder; }
set { activeOrder = value; }
}
public Int32 PendingOrder
{
get { return pendingOrder; }
set { pendingOrder = value; }
}
public DateTime Date
{
get { return date; }
set { date = value; }
}
#endregion
}

public class CumulativeCollection : CollectionBase
{
public Cumulative this[int index]
{
get
{
return (Cumulative)List[index];
}
}

public void Add(Cumulative obj)
{
List.Add(obj);
}

public void Remove(Cumulative obj)
{
List.Remove(obj);
}

public bool Contains(Cumulative obj)
{
return List.Contains(obj);
}

public void Insert(int index, Cumulative obj)
{
InnerList.Insert(index, obj);
}

public void Sort()
{
InnerList.Sort(null);
}
public void Sort(string sortField, string sortOrder)
{
CompareCollection comparer = new CompareCollection();
comparer.SortField = sortField;
comparer.SortOrder = sortOrder;
this.InnerList.Sort(comparer);

}

public void CopyTo(Cumulative[] array, int index)
{
((ICollection)this).CopyTo(array, index);
}

public int IndexOf(Cumulative value)
{
return ((IList)this).IndexOf(value);
}
}
}

public class test{

public void main(){

Cumulative objCumulative = new Cumulative();
objCumulative.RawData = 11;
objCumulativeCollection.Sort(“RawData”, “ASC”);

}

}

Make sure that the title tag contains text which a human can relate to. The text within the title tag is what shows up in a search result. Treat it like a headline.

2. Use the same keywords as anchor text to link to the page from different pages on your site. This is especially useful if your site contains many pages. The more keywords that link to a specific page the better.

3. Make sure that the text within the title tag is also within the body of the page. It is unwise to have keywords in the title tag which are not contained within the body of the page.

Adding the exact same text for your h1 tag will tell the reader who clicks on your page from a search engine result that they have clicked on the correct link and have arrived at the page where they intended to visit. Robots like this too because now there is a relation between the title of your page and the headline.

Also, sprinkle your keywords throughout your article. The most important keywords can be bolded or colored in red. A good place to do this is once or twice in the body at the top of your article and in the sub-headings.

4. Do not use the exact same title tag on every page on your website. Search engine robots might determine that all your pages are the same if all your title tags are the same. If this happens, your pages might not get indexed.

I always use the headline of my pages as the title tag to help the robots know exactly what my page is about. A good place to insert the headline is within the h1 tag. So the headline is the same as the title tag text.

5. Do not spam the description or keyword meta tag by stuffing meaningless keywords or even spend too much time on this tag. SEO pros all agree that these tags are not as important today as they once were. I just place my headline once within the keywords and description tags.

6. Do not link to link-farms or other search engine unfriendly neighborhoods.

7. Do not use doorway pages. Doorway pages are designed for robots only, not humans. Search engines like to index human friendly pages which contain content which is relevant to the search.

8. Title tags for text links. Insert the title tag within the HTML of your text link to add weight to the link and the page where the link resides. This is like the alt tag for images.

My site contains navigation menus on the left and right of the page. The menu consists of links not images. When you hover over the link with your mouse, the title of the link appears. View the source of this page to see how to add this tag to your links.

9. Describe your images with the use of the alt tag. This will help search engines that index images to find your pages and will also help readers who use text only web browsers.

10. Submit to the search engines yourself. Do not use a submission service or submission software. Doing so could get your site penalized or even banned.

Here is the submission page for google: http://www.google.com/addurl.html

Scalar Functions

Scalar functions return a data type such as int, money, varchar, real, etc. They can be used anywhere a built-in SQL function is allowed. The syntax for a scalar function is the following:

CREATE FUNCTION dbo.Factorial ( @iNumber int )
RETURNS INT
AS
BEGIN
DECLARE @i	int

	IF @iNumber <= 1
		SET @i = 1
	ELSE
		SET @i = @iNumber * dbo.Factorial( @iNumber - 1 )
RETURN (@i)
END

II.  In-Line Table Functions

In-line table functions are functions that return the output of a single SELECT statement as a table data type.   Since this type of function returns a table, the output can be used in joins of queries as if it was a standard table. The syntax for an in-line table function is as follows:

II.  In-Line Table Functions

In-line table functions are functions that return the output of a single SELECT statement as a table data type.   Since this type of function returns a table, the output can be used in joins of queries as if it was a standard table. The syntax for an in-line table function is as follows:
CREATE FUNCTION dbo.AuthorsForState(@cState char(2) )
RETURNS TABLE
AS
RETURN (SELECT * FROM Authors WHERE state = @cState)

III. Multistatement Table Functions Multistatement table functions are similar to stored procedures except that they return a table.  This type of function is suited to address situations where more logic is required than can be expressed in a single query.  The following is the syntax for a multistatement table function:
CREATE FUNCTION dbo.GetManagerReports ( @iEmployeeID int )
RETURNS @ManagerReports TABLE
   (
   	EmployeeID			int,
   	EmployeeFirstName     		nvarchar(10),
   	EmployeeLastName 		nvarchar(20),
	Title				nvarchar(30),
	TitleOfCourtesy			nvarchar(25),
	Extension			nvarchar(4),
   	ManagerID			int
   )
AS
BEGIN

	DECLARE

@iRowsAdded	int, 		-- Counts rows added to
-- table with each iteration
	@PREPROCESSED			tinyint,		-- Constant
for record prior
-- to processing
	@PROCESSING			tinyint,		-- Constant
for record
-- being processed
	@POSTPROCESSED			tinyint		-- Constant for
records that
-- have been processed

	SET	@PREPROCESSED 		= 0
	SET	@PROCESSING 		= 1
	SET	@POSTPROCESSED 		= 2

	DECLARE	@tblReports TABLE (
-- Holds employees added with each pass thru source employees table
		EmployeeID				int,
   		EmployeeFirstName     			nvarchar(10),
   		EmployeeLastName 			nvarchar(20),
		Title					nvarchar(30),
		TitleOfCourtesy				nvarchar(25),
		Extension				nvarchar(4),
   		ManagerID				int,
		ProcessedState				tinyint
	DEFAULT 0
		)

	--Begin by adding employees who report to the Manager directly.
	INSERT INTO @tblReports
	SELECT EmployeeID, FirstName, LastName, Title, TitleOfCourtesy,
Extension, ReportsTo, @PREPROCESSED
		FROM Employees
	WHERE ReportsTo = @iEmployeeID

	--Save number of direct reports
	SET @iRowsAdded = @@ROWCOUNT

	-- Loop through Employees table until no more iterations are necessary
	--	(e.g., no more rows added) to add all indirect reports.
	WHILE @iRowsAdded > 0
	BEGIN
		--Set just added employees ProcessedState to PROCESSING
-- (for first pass)
		UPDATE @tblReports
			SET ProcessedState = @PROCESSING
		WHERE ProcessedState = @PREPROCESSED

		--Add employees who report to Managers in
-- ProcessedState = PROCESSING
		INSERT INTO @tblReports
SELECT e.EmployeeID, e.FirstName, e.LastName, e.Title,
e.TitleOfCourtesy, e.Extension, e.ReportsTo, @PREPROCESSED
			FROM Employees e
INNER JOIN @tblReports r ON e.ReportsTo = r.EmployeeID
		WHERE r.ProcessedState = @PROCESSING
			AND e.ReportsTo <> @iEmployeeID

		--Save number of rows added for this iteration
		SET @iRowsAdded = @@ROWCOUNT

--Set ProcessedState to POSTPROCESSED for Managers whose
--reports were added in this iteration
		UPDATE @tblReports
			SET ProcessedState = @POSTPROCESSED
		WHERE ProcessedState = @PROCESSING
	END

	--Save all data to output table
	INSERT INTO @ManagerReports
SELECT EmployeeID, EmployeeFirstName, EmployeeLastName, Title,
TitleOfCourtesy, Extension, ManagerID
		FROM @tblReports
   	RETURN
END

magic table two part
1)Inserted
 a)Insert
 b)update
2)Deleted

MAGIC TABLES NOTHING BUT INSERTED AND DELETED WHICH ARE
TEMPORARY OBJECTS CREATED BY SERVER INTERNALLY TO HOLD
RECENTLY INSERTED VALUES IN THE CASE OF INSERT,TO HOLD
RECENTLY DELETED VALUES IN THE CASE OF DELETE,TO HOLD
BEFORE UPDATING VALUES OR AFTER UPDATING VALUES IN THE CASE
OF UPDATE.
]]> http://webfunda.wordpress.com/2009/12/22/what-are-magic-table/feed/ 0 Praveen Srivastava http://webfunda.wordpress.com/2009/12/22/difference-between-stuff-replace-function/ http://webfunda.wordpress.com/2009/12/22/difference-between-stuff-replace-function/#comments Tue, 22 Dec 2009 11:40:29 +0000 Praveen Srivastava http://webfunda.wordpress.com/?p=7 ]]> STUFF function is used to overwrite existing characters.
Using this syntax, STUFF (string_expression,start,length,replacement_characters)

where
string_expression is the string that will have characters substituted,
start is the starting position,
length is the number of characters in the string that are substituted, and replacement_characters are the new characters interjected into the string.

If we only wanted to replace the first one, Replace wouldn’t work, since it always replaces ALL occurrences of the string. But Stuff would, since it only replaces the string it finds at the starting location we tell it for the number of chars we want it to replace.

select stuff('Hello world',7, 5,'Manish')

Result: Hello Manish

REPLACE function to replace existing characters of all occurrences.

Using the syntax REPLACE (string_expression, search_string, replacement_string), where every incidence of search_string found in the string_expression will be replaced with replacement_string.

select replace('welcome in C# Corner','el','c')

Result: wccome in C# Corner

Here the function takes two inputs

1) URL – Location where we have to  save data.
2) Data – Variable which will be a array of data to be saved at remote Location.

function multiRequest($data, $url) {
// array of curl handles
$curly = array();
// data to be returned
$result = array();

// multi handle
$mh = curl_multi_init();

// loop through $data and create curl handles
// then add them to the multi-handle
foreach ($data as $id => $d) {

$curly[$id] = curl_init();

$post = array(
“filename”=> $d
);

curl_setopt($curly[$id], CURLOPT_HEADER, 0);
curl_setopt($curly[$id], CURLOPT_VERBOSE, 0);
curl_setopt($curly[$id], CURLOPT_RETURNTRANSFER, true);
curl_setopt($curly[$id], CURLOPT_USERAGENT, “Mozilla/4.0 (compatible;)”);
curl_setopt($curly[$id], CURLOPT_URL, $url);
curl_setopt($curly[$id], CURLOPT_POST, true);
curl_setopt($curly[$id], CURLOPT_POSTFIELDS, $post);

curl_multi_add_handle($mh, $curly[$id]);
}

// execute the handles
$running = null;
do {
curl_multi_exec($mh, $running);
} while($running > 0);

// get content and remove handles
foreach($curly as $id => $c) {
$result[$id] = curl_multi_getcontent($c);
curl_multi_remove_handle($mh, $c);
}

// all done closing the curl
curl_multi_close($mh);

return $result;
}