Raha mitady aide momba ny SQL ianao, dia ity no mba atoroko anao kely. Ahitanao ireo references rehetra ilaina izy ireo ary ahitanao ihany koa fampitahana. Tsara raha jerenao mihitsy raha mety.
Link to SQL dialects reference - Wikibooks, collection of open-content textbooks
[edit]
The Clinical Informatics Wiki is an implementation of a wiki devoted to topics in clinical informatics. To begin a new article, or edit an existing article, you must first create an account and login to the ClinfoWiki.
Please see documentation on customizing the interface and the User's Guide for usage and configuration help.
You can test your edits as much as you want in the Sandbox.
We are currently working on 331 articles, and we need your help to complete this study of Clinical Informatics. See Special:Statistics for more complete information on the site.
[edit]
One of the painful things about good old ASP was string formatting, VBScript simply didn't have anything useful. C# (and VB.Net) do, but MSDN doesn't provide a quick reference to the formatting options. So here's a quick reference.
To compare string formatting in C# to those in C lets have an example,
char szOutput[256];
sprintf(szOutput, "At loop position %d.\n", i);
sprintf takes an output buffer, a format string and any number of arguments to substitute into the format string.
The C# equivalent for sprintf is String.Format, which takes a format string and the arguments. It returns a string, and because you're not passing in a buffer there's no chance of a buffer overflow.
string outputString = String.Format("At loop position {0}.\n", i);
So why doesn't have the format argument have parameters specifying what data type you're formatting? The CLR objects have metadata which informs the CLR what the objects are, and each object has a standard ToString() method which returns a string representation of that object. Much nicer than C where if you passed the wrong type of variable into sprintf everything could come crashing down.
The ToString method can accept a string parameter which tells the object how to format itself. In the call to String.Format , the formatting string is passed after the position, for example, "{0:##}". The text inside the curly braces is {argumentIndex[,alignment][:formatString]}. If alignment is positive, the text is right-padding to fill the specified field length, if it's negative, it's left-padded.
There's not much formatting that can be applied to a string. Only the padding / alignment formatting options can be applied. These options are also available to every argument, regardless of type.
example
output
String.Format("--{0,10}--", "test");
-- test--
String.Format("--{0,-10}--", "test");
--test --
....
Voici une page web de classification CIM10 faite par HCUGE suisse
Il est léger et facile à utiliser
CIM10
_ (A00-B99) Certaines maladies infectieuses et parasitaires 1
_ (C00-D48) Tumeurs 2
_ (D50-D89) Mal. du sang et des org. hématopoïét. et certains troub. syst. immun. 3
_ (E00-E90) Maladies endocriniennes, nutritionnelles et métaboliques 4
_ (F00-F99) Troubles mentaux et du comportement 5
_ (G00-G99) Maladies du système nerveux 6
_ (H00-H59) Maladies de l'oeil et de ses annexes 7
_ (H60-H95) Maladies de l'oreille et de l'apophyse mastoïde 8
_ (I00-I99) Maladies de l'appareil circulatoire 9
_ (J00-J99) Maladies de l'appareil respiratoire 10
_ (K00-K93) Maladies de l'appareil digestif 11
_ (L00-L99) Maladies de la peau et du tissu cellulaire sous-cutané 12
_ (M00-M99) Maladies du système ostéo-articulaire, des muscles et du tissu conj 13
_ (N00-N99) Maladies de l'appareil génito-urinaire 14
_ (O00-O99) Grossesse, accouchement et puerpéralité 15
_ (P00-P96) Certaines affections dont l'origine se situe dans la période périna 16
_ (Q00-Q99) Malformations congénitales et anomalies chromosomiques 17
_ (R00-R99) Symptomes, signes et résultats anormaux examens cliniques et labo 18
_ (S00-T98) Lésions trauma, empoisonnements certaines conséquences causes externes 19
_ Codes "U" selon CIM-10 vol2 page 18 22
_ (V01-Y98) Causes externes de morbidité et de mortalité 20
_ (Z00-Z99) Facteurs influant état santé et motifs recours aux services santé 21
http://www.phpbuilder.com/columns/vaska20050722.php3
10 Tips That Every PHP Newbie Should Know
I wish I had known these 10 tips the day I started working with PHP. Instead of learning them through painstaking process, I could have been on my way to becoming a PHP programmer even sooner! This article is presented in two parts and is intended for folks who are new to PHP.
Tip 1: MySQL Connection Class
The majority of web applications I've worked with over the past year have used some variation of this connection class:
class DB {
function DB() {
$this->host = "localhost"; // your host
$this->db = "myDatabase"; // your database
$this->user = "root"; // your username
$this->pass = "mysql"; // your password
$this->link = mysql_connect($this->host, $this->user,
$this->pass);
mysql_select_db($this->db);
}
}
.......lire l'original ici
Often it is not possible to know in advance the criteria for a query field. In such cases, where the filter values are not known until runtime, a variable (parameter) can be used. When these queries are run, the user is prompted for the value of each parameter. (The parameters can also be assigned programmatically). Using parameters in queries is extremely powerful and converts static "hard-coded" queries to flexible, dynamic ones. The use of parameters can significantly reduce the number of queries you need, makes queries more useful, and simplifies database maintenance.
Parameters can be added very easily. Rather than entering the value of a criteria, enter between brackets the prompt you want the user to see when the query is run. The value the user enters replaces the parameter in the query. In the following example, a parameter [Enter State Name:] is the criteria in the [State] field, and [Enter Minimum Age:] is the parameter in the [Age] field. When this query is run, the user is prompted for the state desired and minimum age, and the records matching that value are retrieved.
Parameters work provided the parameter definition does not conflict with the field name among the query's tables.
To better define a parameter, you should define it in the list of parameters. This is an optional step, but there are good reasons to do so, right mouse click on the top part of the query and choose Parameters. This form appears to let you list each parameter name and its type:
By explicitly defining parameters, users are forced to enter values conforming to the type. While it may not matter for text fields, it is useful for numeric and date fields. This will minimize data entry errors that cause a "Can't evaluate expression" error message to appear.
One of the most powerful features of Microsoft Access queries is their support for Access functions. This is most useful in Update queries, but can also be used in Select queries. The Advanced: Access Functions query is an example of this feature:
This query selects the Country names in descending order of name length. The second field renames itself to [Length], uses the LEN function to calculate the length of each country name, sorts the length in descending order, and excludes any records with 10 letters or fewer.
While this may not seem particularly useful, there are many situations where using Access functions is extremely useful and eliminates the need to program. The string functions in particular (Left$, Right$, Trim$, Mid$, UCase$, LCase$ etc.) are useful for manipulating portions of strings and changing case.
In addition to using Microsoft Access functions, queries also support user defined functions. Functions defined in Access Basic/VBA modules must return an appropriate value and can be used to manipulate each record. You can reference field values by passing the field name in brackets.
Here is an example where a function (StripLead) is used to remove the leading word of a phrase if it starts with "The", "An", or "A". This is useful for sorting phrases such as book titles on "real" words:
Link to FMS Technical Papers - Microsoft Access Query Tips and Techniques
.NET Defined
OOP with VB
VB Language
Win Forms
Windows Controls
ADO .NET
-Using Server Explorer
-Using DataReader
-Using Sql Provider
-Using OleDb Provider
-Using MSAccess
-Data Adapter Configuration Wizard
-Simple Binding
-Data Form Wizard
-Creating DataTables
-SQL Parameters
User Controls
File Handling
Multithreading
Deployment
XML Web Services Essential XML
Resources
Discussions
ASP.NET
About
Advertisement
Home> ADO .NET
ADO .NET
Most applications need data access at one point of time making it a crucial component when working with applications. Data access is making the application interact with a database, where all the data is stored. Different applications have different requirements for database access. VB .NET uses ADO .NET (Active X Data Object) as it's data access and manipulation protocol which also enables us to work with data on the Internet. Let's take a look why ADO .NET came into picture replacing ADO.
Evolution of ADO.NET
The first data access model, DAO (data access model) was created for local databases with the built-in Jet engine which had performance and functionality issues. Next came RDO (Remote Data Object) and ADO (Active Data Object) which were designed for Client Server architectures but soon ADO took over RDO. ADO was a good architecture but as the language changes so is the technology. With ADO, all the data is contained in a recordset object which had problems when implemented on the network and penetrating firewalls. ADO was a connected data access, which means that when a connection to the database is established the connection remains open until the application is closed. Leaving the connection open for the lifetime of the application raises concerns about database security and network traffic. Also, as databases are becoming increasingly important and as they are serving more people, a connected data access model makes us think about its productivity. For example, an application with connected data access may do well when connected to two clients, the same may do poorly when connected to 10 and might be unusable when connected to 100 or more. Also, open database connections use system resources to a maximum extent making the system performance less effective.
Why ADO.NET?
To cope up with some of the problems mentioned above, ADO .NET came into existence. ADO .NET addresses the above mentioned problems by maintaining a disconnected database access model which means, when an application interacts with the database, the connection is opened to serve the request of the application and is closed as soon as the request is completed. Likewise, if a database is Updated, the connection is opened long enough to complete the Update operation and is closed. By keeping connections open for only a minimum period of time, ADO .NET conserves system resources and provides maximum security for databases and also has less impact on system performance. Also, ADO .NET when interacting with the database uses XML and converts all the data into XML format for database related operations making them more efficient.