飛奔嘅蝸牛

HTML, ASP, PHP, Perl, VBScript, JavaScript, CSS, XML, XSLT, XSLT2, XML Schema, WML files

jscript.zip (2007-05-10)

JScript stx with Prototype.js – W. Jordan

jscript.acp.zip (2007-05-10)

JScript acp, ctl with Prototype.js – W. Jordan

css.acp.zip (2007-05-10)

CSS acp, ctl – W. Jordan

asp_cs.zip (2007-05-10)

ASP.net with C# acp, ctl – W. Jordan

wsdl.zip (2007-04-05)

WSDL stx – Derli Marcochi

xslt2_acp.zip (2007-03-02)

XSLT2 acp, ctl – W. Jordan

xslt_acp.zip (2007-03-02)

XSLT acp, ctl – W. Jordan

ansi_meu.zip (2006-12-07)

ASCII to HTML acp, ctl (Portuguese) – Armindo Lapa

htmlbar3.zip (2006-12-04)

HTML toolbar for HTML and XHTML updated – Kartros

podcasting.zip (2006-06-16)

Apple iPod iTunes Podcasting (RSS/XML).stx – Valerio Capello

filezilla.zip (2006-06-13)

FileZilla Settings file (XML) stx – Valerio Capello

php514.zip (2006-05-08)

PHP 5.1.4 stx – BiHon

html_dotnet.zip (2006-04-27)

Html with Asp.net ctl – dp-U-To Solutions

css3.zip (2006-04-19)

CSS stx – W. Jordan

htmlbar2.zip (2006-03-30)

HTML toolbar for HTML and XHTML – Martin “Shuster” Švec

asp_net_20.zip (2006-03-21)

ASP.NET (C#, ASP/ADO.NET, VB) ctl, template – Dimitrios Markatos

php16.zip (2006-02-22)

PHP stx – Julien Perez

php5x.zip (2006-01-30)

PHP 5.x stx – Will Buckner

js5.zip (2005-11-17)

JavaScript stx – Ze Thriller

html_asp.zip (2005-11-15)

HTML with ASP.net 2 Web Controls stx – W. Jordan

asp_cs2.zip (2005-11-15)

ASP.net with C# for .Net Framework 2 stx – W. Jordan

dhtml.zip (2005-10-20)

DHTML Events ctl – Daniel Guinn

ant_2020.zip (2005-10-04)

xml ANT (A Neat Tool) stx – Greg Presedo-Floyd

csdoc.zip (2005-09-30)

C# XML Documentation ctl – W. Jordan

gps_xml.zip (2005-09-19)

GPS xml (Google Earth KML XML, Geocaching XML, GPX XML) stx – Valerio Capello

xul.zip (2005-08-27)

XUL (XML-based User Interface Language) stx – rgv151

php504.zip (2005-08-01)

PHP 5.0.4 stx, acp – Bernhard Kirchen

php.5.0.4.zip (2005-05-07)

php 5.0.4 stx – Ilya V. Glazkov

php_stx2.zip (2005-04-11)

PHP 5.0.4 stx – Timofei Ivaschenko

php-5.0.3.zip (2005-03-25)

PHP 5.0.3 stx – Stoyan Dimitrov

php_acp3.zip (2005-03-24)

PHP acp – Iuri Carraro

wsf2.zip (2004-08-27)

Windows Script Host with JScript stx, acp – W. Jordan

php503.zip (2005-01-08)

PHP 5.0.3 stx – Seung Hwan Kang

plsql3.zip (2007-10-22)

pl/sql Oracle’s procedure language stx – Mark Huber

mysql3.zip (2007-07-30)

MySQL 5.0 stx – Harry Long

ms-tsql.zip (2007-06-04)

Microsoft T-SQL 7.0 stx – Matthew Black

java_1_6_0.zip (2007-02-06)

Java SE 6 (1.6.0) stx – Тимофей Иващенко

cpp_qt.zip (2006-11-21)

C++ Qt 4.2.0/ANSI stx – Павел Спицин Валерьевич

esql.zip (2006-11-20)

ESQL for IBM Websphere Message Broker stx, acp – Sridar Swaminathan

java.rar (2006-08-17)

Java 2 SE Development Kit 5.0 (1.5.0) stx – Тимофей Иващенко

sql4.zip (2006-03-20)

SQL stx – George Alatrash

cpp7.zip (2006-03-18)

C++ stx (POSIX/ANSI/STL) – 임유빈 님

velocity.zip (2006-02-01)

Velocity for Java (*.vm) stx – Alon Halimi

cs2.zip (2005-11-15)

C# for .Net Framework 2 stx – W. Jordan

java_1_4_2.zip (2005-10-10)

Java 1.4.2 stx and Java syntax file generator software – Тим

sql3.zip (2005-09-17)

C/C++ with SQL stx – Marcos Moya

dp_div.zip (2005-08-25)

JavaScript ctl – dp-U-To Solutions

mayacpp.zip (2005-08-04)

C++ with Maya API class names stx – David Chen

mysql2.zip (2005-07-23)

MySQL stx – rgv151

mobilec.zip (2005-06-07)

Mobile C (GVM, GNEX) stx, acp – 이근수 님

cpp_ctl.zip (2005-04-27)

C++ ctl – Allen Varner 2005

cpp_sym.zip (2005-03-23)

C++ Programming for Symbian OS (Series 60) stx – Gaurav Jain

plpg_postgre.zip (2004-11-23)

PL/pgSQL and PostgreSQL (7.4.5) stx, acp – Tomek Jakubas

dotnet11.zip (2005-01-19)

C# with .Net Framework 1.1 stx – W. Jordan

cpp8.zip (2005-01-18)

C/C++ (enhanced) stx – Tim

How MySQL Optimises ORDER BY

In some cases MySQL can uses index to satisfy an ORDER BY or GROUP BY request without doing any extra sorting.

The index can also be used even if the ORDER BY doesn’t match the index exactly, as long as all the unused index parts and all the extra are ORDER BY columns are constants in the WHERE clause. The following queries will use the index to resolve the ORDER BY / GROUP BY part:

SELECT * FROM t1 ORDER BY key_part1,key_part2,…
SELECT * FROM t1 WHERE key_part1=constant ORDER BY key_part2
SELECT * FROM t1 WHERE key_part1=constant GROUP BY key_part2
SELECT * FROM t1 ORDER BY key_part1 DESC,key_part2 DESC
SELECT * FROM t1 WHERE key_part1=1 ORDER BY key_part1 DESC,key_part2 DESC

Some cases where MySQL can not use indexes to resolve the ORDER BY: (Note that MySQL will still use indexes to find the rows that matches the WHERE clause):

* You are doing an ORDER BY on different keys: SELECT * FROM t1 ORDER BY key1,key2
* You are doing an ORDER BY using non-consecutive key parts. SELECT * FROM t1 WHERE key2=constant ORDER BY key_part2
* You are mixing ASC and DESC. SELECT * FROM t1 ORDER BY key_part1 DESC,key_part2 ASC
* The key used to fetch the rows are not the same one that is used to do the ORDER BY: SELECT * FROM t1 WHERE key2=constant ORDER BY key1
* You are joining many tables and the columns you are doing an ORDER BY on are not all from the first not-const table that is used to retrieve rows (This is the first table in the EXPLAIN output which doesn’t use a const row fetch method).
* You have different ORDER BY and GROUP BY expressions.
* The used table index is an index type that doesn’t store rows in order. (Like the HASH index in HEAP tables).

In the cases where MySQL have to sort the result, it uses the following algorithm:

* Read all rows according to key or by table scanning. Rows that don’t match the WHERE clause are skipped.
* Store the sort-key in a buffer (of size sort_buffer).
* When the buffer gets full, run a qsort on it and store the result in a temporary file. Save a pointer to the sorted block. (In the case where all rows fits into the sort buffer, no temporary file is created)
* Repeat the above until all rows have been read.
* Do a multi-merge of up to MERGEBUFF (7) regions to one block in another temporary file. Repeat until all blocks from the first file are in the second file.
* Repeat the following until there is less than MERGEBUFF2 (15) blocks left.
* On the last multi-merge, only the pointer to the row (last part of the sort-key) is written to a result file.
* Now the code in `sql/records.cc’ will be used to read through them in sorted order by using the row pointers in the result file. To optimise this, we read in a big block of row pointers, sort these and then we read the rows in the sorted order into a row buffer (read_rnd_buffer_size) .

You can with EXPLAIN SELECT … ORDER BY check if MySQL can use indexes to resolve the query. If you get Using filesort in the extra column, then MySQL can’t use indexes to resolve the ORDER BY. See section 5.2.1 EXPLAIN Syntax (Get Information About a SELECT).

If you want to have a higher ORDER BY speed, you should first see if you can get MySQL to use indexes instead of having to do an extra sorting phase. If this is not possible, then you can do:

* Increase the size of the sort_buffer_size variable.
* Increase the size of the read_rnd_buffer_size variable.
* Change tmpdir to point to a dedicated disk with lots of empty space. If you use MySQL 4.1 or later you can spread load between several physical disks by setting tmpdir to a list of paths separated by colon : (semicolon ; on Windows). They will be used in round-robin fashion. Note: These paths should end up on different physical disks, not different partitions of the same disk.

By default, MySQL sorts all GROUP BY x,y[,…] queries as if you specified ORDER BY x,y[,…] in the query as well. If you include the ORDER BY clause explicitly, MySQL optimises it away without any speed penalty, though the sorting still occurs. If a query includes GROUP BY but you want to avoid the overhead of sorting the result, you can supress sorting by specifying ORDER BY NULL:

INSERT INTO foo SELECT a,COUNT(*) FROM bar GROUP BY a ORDER BY NULL;

This trail covers the fundamentals of programming in the Java programming language.

 Object-Oriented Programming Concepts teaches you the core concepts behind object-oriented programming: objects, messages, classes, and inheritance. This lesson ends by showing you how these concepts translate into code. Feel free to skip this lesson if you are already familiar with object-oriented programming.

 Language Basics describes the traditional features of the language, including variables, arrays, data types, operators, and control flow.

 Classes and Objects describes how to write the classes from which objects are created, and how to create and use the objects.

 Interfaces and Inheritance describes interfaces—what they are, why you would want to write one, and how to write one. This section also describes the way in which you can derive one class from another. That is, how a subclass can inherit fields and methods from a superclass. You will learn that all classes are derived from the Object class, and how to modify the methods that a subclass inherits from superclasses.

 Numbers and Strings This lesson describes how to use Number and String objects The lesson also shows you how to format data for output.

 Generics are a powerful feature of the Java programming language. They improve the type safety of your code, making more of your bugs detectable at compile time.

 Packages are a feature of the Java programming language that help you to organize and structure your classes and their relationships to one another.

This lesson explains how to bundle classes and interfaces into packages, how to use classes that are in packages, and how to arrange your file system so that the compiler can find your source files.

Generics are a built-in language feature that will make your software more reliable. This lesson discusses the following topics:

Introduction

This section explains some common shortcomings associated with non-generic code. Specifically, it shows how certain kinds of bugs will crash an application at runtime, since they are not detectable by the compiler.

Generic Types

This section explains generic type declarations, type variables, type parameters, and type arguments. It also describes the naming conventions that are specific to generics.

Generic Methods and Constructors

This section shows how type parameters can be used to define generic methods and constructors.

Bounded Type Parameters

This section describes how type parameters can specify an upper bound that limits the kind of types that can be passed in.

Subtyping

This section describes how generic subtyping differs from non-generic subtyping.

Wildcards

This section continues the discussion of subtyping by describing bounded and unbounded wildcards.

Type Erasure

This section describes type erasure, raw types, and unchecked warnings.

When a generic type is instantiated, the compiler translates those types by a technique called type erasure — a process where the compiler removes all information related to type parameters and type arguments within a class or method. Type erasure enables Java applications that use generics to maintain binary compatibility with Java libraries and applications that were created before generics.

For instance, Box<String> is translated to type Box, which is called the raw type — a raw type is a generic class or interface name without any type arguments. This means that you can’t find out what type of Object a generic class is using at runtime. The following operations are not possible:

public class MyClass<E> {

    public static void myMethod(Object item) {

        if (item instanceof E) {  //Compiler error

            …

        }

        E item2 = new E();   //Compiler error

        E[] iArray = new E[10]; //Compiler error

        E obj = (E)new Object(); //Unchecked cast warning

    }

}

The operations shown in bold are meaningless at runtime because the compiler removes all information about the actual type argument (represented by the type parameter E) at compile time.

Type erasure exists so that new code may continue to interface with legacy code. Using a raw type for any other reason is considered bad programming practice and should be avoided whenever possible.

When mixing legacy code with generic code, you may encounter warning messages similar to the following:

Note: WarningDemo.java uses unchecked or unsafe operations.

Note: Recompile with -Xlint:unchecked for details.

This can happen when using an older API that operates on raw types, as shown in the following WarningDemo program:

public class WarningDemo {

    public static void main(String[] args){

        Box<Integer> bi;

        bi = createBox();

    }

    /**

     * Pretend that this method is part of an old library,

     * written before generics. It returns

     * Box instead of Box<T>.

     */

    static Box createBox(){

        return new Box();

    }

}

Recompiling with -Xlint:unchecked reveals the following additional information:

WarningDemo.java:4: warning: [unchecked] unchecked conversion

found   : Box

required: Box<java.lang.Integer>

        bi = createBox();

                      ^

1 warning

Earlier we mentioned that English is ambiguous. The phrase “animal cage” can reasonably mean “all-animal cage”, but it also suggests an entirely different concept: a cage designed not for any kind of animal, but rather for some kind of animal whose type is unknown. In generics, an unknown type is represented by the wildcard character “?“.

To specify a cage capable of holding some kind of animal:

	Cage<? extends Animal> someCage = …;

Read “? extends Animal” as “an unknown type that is a subtype of Animal, possibly Animal itself”, which boils down to “some kind of animal”. This is an example of a bounded wildcard, where Animal forms the upper bound of the expected type. If you’re asked for a cage that simply holds some kind of animal, you’re free to provide a lion cage or a butterfly cage.

---

Note: It’s also possible to specify a lower bound by using the super keyword instead of extends. The code <? super Animal>, therefore, would be read as “an unknown type that is a supertype of Animal, possibly Animal itself”. You can also specify an unknown type with an unbounded wilcard, which simply looks like <?>. An unbounded wildcard is essentially the same as saying <? extends Object>.

---

While Cage<Lion> and Cage<Butterfly> are not subtypes of Cage<Animal>, they are in fact subtypes of Cage<? extends Animal>:

	someCage = lionCage; // OK

	someCage = butterflyCage; // OK

So now the question becomes, “Can you add butterflies and lions directly to someCage?”. As you can probably guess, the answer to this question is “no”.

	someCage.add(king);	// compiler-time error

	someCage.add(monarch);	// compiler-time error

If someCage is a butterfly cage, it would hold butterflies just fine, but the lions would be able to break free. If it’s a lion cage, then all would be well with the lions, but the butterflies would fly away. So if you can’t put anything at all into someCage, is it useless? No, because you can still read its contents:

	void feedAnimals(Cage<? extends Animal> someCage) {

	    for (Animal a : someCage)

		a.feedMe();

	}

Therefore, you could house your animals in their individual cages, as shown earlier, and invoke this method first for the lions and then for the butterflies:

	feedAnimals(lionCage);

	feedAnimals(butterflyCage);

Or, you could choose to combine your animals in the all-animal cage instead:

	feedAnimals(animalCage);

As you already know, it’s possible to assign an object of one type to an object of another type provided that the types are compatible. For example, you can assign an Integer to an Object, since Object is one of Integer‘s supertypes:

    Object someObject = new Object();

    Integer someInteger = new Integer(10);

    someObject = someInteger; // OK

In object-oriented terminology, this is called an “is a” relationship. Since an Integer is a kind of Object, the assignment is allowed. But Integer is also a kind of Number, so the following code is valid as well:

    public void someMethod(Number n){

        // method body omitted

    }

    someMethod(new Integer(10)); // OK

    someMethod(new Double(10.1)); // OK

The same is also true with generics. You can perform a generic type invocation, passing Number as its type argument, and any subsequent invocation of add will be allowed if the argument is compatible with Number:

    Box<Number> box = new Box<Number>();

    box.add(new Integer(10)); // OK

    box.add(new Double(10.1)); // OK

Now consider the following method:

    public void boxTest(Box<Number> n){

        // method body omitted

    }

What type of argument does it accept? By looking at its signature, we can see that it accepts a single argument whose type is Box<Number>. But what exactly does that mean? Are you allowed to pass in Box<Integer> or Box<Double>, as you might expect? Surprisingly, the answer is “no”, because Box<Integer> and Box<Double> are not subtypes of Box<Number>.

Understanding why becomes much easier if you think of tangible objects — things you can actually picture — such as a cage:

	// A cage is a collection of things, with bars to keep them in.

	interface Cage<E> extends Collection<E&gt$$

---

Note: The Collection interface is the root interface of the collection hierarchy; it represents a group of objects. Since a cage would be used for holding a collection of objects (the animals), it makes sense to include it in this example.

---

A lion is a kind of animal, so Lion would be a subtype of Animal:

	interface Lion extends Animal {}

	Lion king = …;

Where we need some animal, we’re free to provide a lion:

	Animal a = king;

A lion can of course be put into a lion cage:

	Cage<Lion> lionCage = …;

	lionCage.add(king);

and a butterfly into a butterfly cage:

	interface Butterfly extends Animal {}

	Butterfly monarch = …;

	Cage<Butterfly> butterflyCage = …;

	butterflyCage.add(monarch);

But what about an “animal cage”? English is ambiguous, so to be precise let’s assume we’re talking about an “all-animal cage”:

	Cage<Animal> animalCage = …;

This is a cage designed to hold all kinds of animals, mixed together. It must have bars strong enough to hold in the lions, and spaced closely enough to hold in the butterflies. Such a cage might not even be feasible to build, but if it is, then:

	animalCage.add(king);

	animalCage.add(monarch);

Since a lion is a kind of animal (Lion is a subtype of Animal), the question then becomes, “Is a lion cage a kind of animal cage? Is Cage<Lion> a subtype of Cage<Animal>?”. By the above definition of animal cage, the answer must be “no”. This is surprising! But it makes perfect sense when you think about it: A lion cage cannot be assumed to keep in butterflies, and a butterfly cage cannot be assumed to hold in lions. Therefore, neither cage can be considered an “all-animal” cage:

	animalCage = lionCage;	// compile-time error

        animalCage = butterflyCage; // compile-time error

Without generics, the animals could be placed into the wrong kinds of cages, where it would be possible for them to escape.