markdown:
# Giáo trình C++ P3
Chia sẻ: Hoang Nguyen | Ngày: | Loại File: PDF | Số trang:0
lượt xem 28
download
![](http://image1.tailieu.vn/document/thumbnail/2009/20091104/hoang3/80x100/chapter03_92.jpg)
##
Giáo trình C++ P3
[Vui lòng tải xuống để xem tài liệu đầy đủ](javascript:void(0);)
Download
![](http://static1.tailieu.vn/b2013az/templates/version1/default/images/down16x21.png)
Introduction to C++
Bình luận(0)
[Đăng nhập để gửi bình luận!](javascript:void(0);)
##
Nội dung Text: Giáo trình C++ P3
- Week 3 Game Institute Introduction to C and C++ by Stan Trujillo www.gameinstitute.com Introduction to C and C++ : Week 3: Page 1 of 47
- © 2001, eInstitute, Inc. You may print one copy of this document for your own personal use. You agree to destroy any worn copy prior to printing another. You may not distribute this document in paper, fax, magnetic, electronic or other telecommunications format to anyone else. This is the companion text to the www.gameinstitute.com course of the same title. With minor modifications made for print formatting, it is identical to the viewable text, but without the audio. www.gameinstitute.com Introduction to C and C++ : Week 3: Page 2 of 47
- Table of Contents Introduction to C++.......................................................................................................................................4 Lesson 3 – Classes.....................................................................................................................................4 Member Functions.................................................................................................................................6 Encapsulation ......................................................................................................................................12 Construtors ..........................................................................................................................................14 Destructors ..........................................................................................................................................16 The this Pointer ...................................................................................................................................20 The Assignment Operator ...................................................................................................................20 Overloaded Operators..........................................................................................................................24 Copy Constructors...............................................................................................................................24 The CmdLine Sample..........................................................................................................................25 Inheritance...........................................................................................................................................32 Inheritance Syntax...............................................................................................................................34 Derived Functionality..........................................................................................................................35 Virtual Functions.................................................................................................................................37 The VirtualPlayer Sample ...................................................................................................................41 What’s next?........................................................................................................................................47 www.gameinstitute.com Introduction to C and C++ : Week 3: Page 3 of 47
- Introduction to C++ A GameInstitute course by Stan Trujillo In Lesson 1 we discussed functions. In Lesson 2 we discussed data structures. In this lesson, we introduce classes, which blend functions and data structures to create a powerful language feature: objects. Using objects, entities can be created that are intelligent and robust in a way that functions or data structures alone cannot be. This single feature is what sets C++ apart from C. At the same time, the C ancestry is not discarded. C++ still benefits from the speed advantages of C, offering much better performance than other object-oriented languages. Using only functions and data structures, as covered in the previous two lessons, is known as procedural programming. Object-oriented programming uses a new paradigm, and as such provides a different way to approach programming. Some advocates of object-orient programming often disparage procedural programming, and insist that programmers give themselves over to this new paradigm completely. They are critical of programmers who mix paradigms (or, worse yet, use C++, but do not use objects), and they are supporters of “pure” object-oriented languages such as Java. The implication is that object-oriented programming is so radically different from procedural programming that everything that you know about procedural techniques should be discarded, and that every feature in every program should be represented as an object or set of objects. But object-oriented programming does not and cannot entirely replace procedural programming. The object-oriented purists seem to forget that objects use functions. Procedural issues such as function calls, arguments, return values, automatic variables, and data types apply to object-oriented programming as much as they do to procedural programming. Object-oriented techniques don’t replace procedural techniques; they augment and enhance them. We didn’t spend the first two lessons studying procedural programming features just for historical reasons. Nor did we do it to demonstrate how horrible these concepts are in contrast to object-oriented features. We need the foundation that procedural programming provides in order to be effective object- oriented programmers. We won’t discard what we’ve learned thus far; we’ll use it to create objects. Having said that, good object oriented programming does require a different mindset. For programmers with extensive procedural experience in particular, this can be a rough transition, because they have to break learned habits. It is not uncommon for these programmers to be very slow to fully adopt object- oriented approaches, which results in code that uses a blend of techniques. In this sense, new programmers who start with object-oriented languages have an advantage. They learn to use objects from the start, and don’t have to fight established thought patterns. Lesson 3 – Classes C++ uses the term class to describe an object definition. A class is a data type, just like an intrinsic data type or a structure. As a data type, classes are blueprints that describe data entities, and can be used to declare variables. Instead of being called variables, however, instances of a class are called objects. Before we can create an object, therefore, we must define the class that describes it. One way to create a class is to use the class keyword, like this: class Player { www.gameinstitute.com Introduction to C and C++ : Week 3: Page 4 of 47
- char name[80]; int score; }; This definition creates a class called Player. The Player class defines two members, name, and score, which can be used to store data about the player. In object-oriented lingo, these data definitions are called data members. In this case the Player class is said to have two data members. The Player class shown above looks almost exactly like the Player structure from Lesson 2. The only difference is the class keyword (the Player structure uses the struct keyword). In fact, there is virtually no difference between a class and a structure. Consider these two definitions: class Player { char name[80]; int score; }; struct Player { char name[80]; int score; }; Both of these definitions define a data type called Player. Both of these types can be used to create variables, and both contain the same data members. In C++, a class and a structure are virtually identical. The only difference is the default permissions. By default, the struct keyword results in a data type whose members are public, whereas the members of a class are private. We know that the contents of the struct are freely accessible (public) because we assigned and inspected them freely in Lesson 2. A class, however, because it is private by default, does not allow access to its data members: class Player { char name[80]; int score; }; Player player; player.score = 0; // compiler error! ‘score’ is private What is the point of a data structure with elements that can’t be accessed? We’ll get to that soon. First, let’s talk about how we can control the accessibility of data members. Access to data members is controlled with the C++ public and private keywords. Using the public keyword makes everything that follows it freely accessible. Likewise, the private keyword restricts access items that follow it. Using the public keyword, we can rewrite the class-based version of Player like this: class Player { public: www.gameinstitute.com Introduction to C and C++ : Week 3: Page 5 of 47
- char name[80]; int score; }; This version of Player provides full access to its data members because they are explicitly declared to be public. The default private permission level of the class keyword is overridden by the use of the public keyword. This version of Player behaves exactly like the Player structure used in Lesson 2. The default permission level of struct can be overridden with the private keyword: struct Player { private: char name[80]; int score; }; This version is effectively the same as the original class-based version; its data members are not publicly accessible. The permission level of each data member can be controlled separately: struct Player { char name[80]; private: int score; }; In this case, name is publicly accessible (because struct is used), but score is not. The effect of public and private takes effect for all of the members that follow, until either the end of the definition is reached (the closing curly brace), or another permissions modifier is encountered. There is no limit to the number of permission modifiers that can be used, and there is no rule against redundant modifiers (usages of public or private that do not change the current permission setting, because the specified permission is already in effect.) When used to modify the access permissions for members, both keywords must be followed by a colon. Despite the fact that there is very little difference between class and struct, the term structure is used to refer to data types that contain only public data members, and the term class is used to refer to types that contain a combination of data types and member functions. We’ll talk about member functions next. Member Functions The goal of object-oriented programming is to create objects that are safe, robust, and easy to use. Although public data members are easy to use, they provide a level of access that is discouraged because they allow anyone to assign any value to any data member. As a result, data members should almost always be private. Instead of direct access, data members are usually accessed via member functions, like this: class Player { public: void SetScore(int s); www.gameinstitute.com Introduction to C and C++ : Week 3: Page 6 of 47
- int GetScore(); private: char name[80]; int score; }; By adding member functions, we now have access—albeit indirect access—to data members that are private. The SetScore function provides a way to assign score, and GetScore provides support for score retrieval (for now we’re providing member functions for only the score data member.) A member function is just like a regular function except that it belongs to a class. It is declared within the class definition, and, as a member of that class, is given access to all data members and member functions present in the class, private or otherwise. Member functions can’t be used outside of the context of the class. The member functions that are now part of the Player class can’t be called without a Player object (a variable of the Player type.) This in is contrast to the functions we’ve been using thus far, that are not part of a class. Non-class member functions are called C functions, or global functions. In the example above, the body of the GetScore and SetScore member functions are not provided, so this class is incomplete. The class has been defined, and the two member functions have been declared, but they have not been defined. We can complete the class by providing the member function bodies inside the class, like this: class Player { public: void SetScore(int s) { score = s; } int GetScore() { return score; } private: char name[80]; int score; }; Notice that the semicolon following each member function in the previous example has been replaced with the function body for each member function. The SetScore function body uses the s parameter to assign the private data member score, and the GetScore function simply returns the value of score. As we discussed in Lesson 1, it is typical to begin function bodies with an opening curly bracket on the line following the function name, but simple member functions that are defined within a class definition are generally an exception to this rule. The formatting shown above is typical for simple accessor functions—member functions that merely provided access to a data member. Alternatively, member functions can be defined outside the class definition, like this: class Player { public: void SetScore(int s); int GetScore(); private: char name[80]; int score; }; www.gameinstitute.com Introduction to C and C++ : Week 3: Page 7 of 47
- void Player::SetScore(int s) { score = s; } int Player::GetScore() { return s; } Although this syntax is not normally used for simple accessor functions like SetScore and GetScore, it is common for functions with more complex function bodies, and for member functions whose class is defined in a header file (we’ll talk about that in Lesson 4). Member functions that are defined outside the class definition must use the C++ scope resolution operator, which is two colons (::). The name that appears to the left of this operator is the class to which the member function belongs, and the name to the right is the member function name. Defining member function outside the class definition is exactly like defining a global function, except that the scope resolution operator is used to indicate the class--or scope--to which the function belongs. If no scope resolution operator were used in the definitions above, the compiler would have no way to know that GetScore and SetScore belong to the Player class. This would cause a compiler error because both functions refer to score, which doesn’t exist outside the Player class. Providing member functions is safer than allowing direct access to data members because you—as the author of a class—can dictate what data values are allowed for each data member. For example, suppose that the game you are writing prohibits the use of negative scores. If the score data member were public, it could be assigned negative values from anywhere in the game code. But because we’ve made it private, we’re requiring that it be set via the SetScore member function. This gives us the opportunity to enforce restrictions on values passed to SetScore. One strategy would be to implement SetScore like this: void Player::SetScore(int s) { if (s >= 0) { score = s; } } This prevents score from being set to a negative value. If a negative value is provided to SetScore, it is simply ignored. This is less than ideal, however, because if a negative value is passed to SetScore, no indication is given that the function call had no effect. We could change the return type of SetScore to bool, and return true if a valid score is provided, and false otherwise, but this means that the caller is expected to check the return value of SetScore each time it is called. Return values are easy to ignore— there is no way to insure that they are checked, or even retrieved. A better solution is to use an assert. An assert is a macro that can be used to force specific conditions within your code. If the condition passed to assert is non-zero (true), assert has no effect. But if the condition resolves to 0 (false), assert halts the executable, and displays the name of the source file and the line where the assertion failed. Using assert requires that the assert.h header file be included, and looks like this when used with the SetScore function: void Player::SetScore(int s) www.gameinstitute.com Introduction to C and C++ : Week 3: Page 8 of 47
- { assert( s >= 0 ); score = s; } This code dictates that values sent to SetScore must be non-negative. If not, execution will halt, and you’ll be informed the exact location of the offending code. The neat thing about assert is that, as a macro, it is defined in such a way that it has absolutely no effect in release builds. As a result, assert can be used liberally, and they’ll announce problems with the code in Debug builds, but the release build will run optimally. Before we continue, let’s provide member functions for the name data member in the Player class. The first step is to declare these functions within the Player class, granting them public access: class Player { public: void SetScore(int s); int GetScore(); void SetName(char* n); char* GetName(); private: char name[80]; int score; }; The SetName member function takes a char pointer as an argument. This will allow callers to provide the address of the player name. Likewise the GetName function returns a pointer to the name, and not the data itself. SetName looks like this: void Player::SetName(char* n) { assert( n ); strcpy( name, n ); } This implementation of SetName uses the provided pointer to copy the contents of the name data member. Notice that an assert is used to mandate that n is non-zero. When dealing with pointers, it’s important to account for the possibility that null pointers will be provided. In this case providing a null- pointer is not allowed, as the SetName function needs the address of a valid string from which to copy the player name. Now we’re ready to write the GetName function. This function returns a pointer to a char, so we can write it like this: char* Player::GetName() { return name; } www.gameinstitute.com Introduction to C and C++ : Week 3: Page 9 of 47
- GetName simply returns the address of the name array. No address of operator is required, because name is an array, and therefore a pointer. This allows us to provide the player name to the calling function without making a copy of the data. The GetName function can be used like this: Player localPlayer; // global object, initialized with a player name elsewhere void DisplayLocalPlayerName() { char* pName = localPlayer.GetName(); // (code to display the name on the screen) } This code works fine, but only if the calling code uses the returned pointer for read-only purposes. There is nothing preventing the code from assigning the content of our private data member, so an errant programmer on the team might do this: Player localPlayer; // global object, initialized with a player name elsewhere void DisplayLocalPlayerName() { char* pName = localPlayer.GetName(); strcpy( pName, “surprise!” ); // (code to display the name on the screen) } This code, using the pointer that we’ve provided, writes a new string to a private data member. The rogue programmer has overwritten the player name with the string “surprise!” This constitutes a breech in the security of our class because our intention was that the only way to assign the name data member was with the SetName member function. Luckily, this problem can be avoided with the const keyword. C++ provides the const keyword to allow the declaration of variables that are “read-only.” Const variables are just like regular variables, but they cannot be modified. The only way to assign a value to a const variable is to initialize it during declaration. Here’s an example: const int MaxPlayers = 10; cout
- // compiler error! const variables must be intialized when declared const int MaxPlayers; Although it is under-used by most programmers, const is a great way to increase the security of your code, and to indicate to programmers using your classes and functions how you intend for them to be used. We can rewrite the Player::GetName function using const like this: class Player { public: void SetScore(int s); int GetScore(); void SetName(char* n); const char* GetName(); private: char name[80]; int score; }; const char* Player::GetName() { return name; } Now the contents of the name data member are safe from unauthorized tampering, thus thwarting our troublesome teammate. Given our changes, let’s revisit his code. Player localPlayer; void DisplayLocalPlayerName() { char* pName = localPlayer.GetName(); // compiler error #1 strcpy( pName, “surprise!” ); // compiler error #2 // (code to display the name on the screen) } This code won’t compile for two reasons. First, you cannot assign a non-const pointer using a const pointer. C++ doesn’t allow this because it would allow you to “throw away” the const modifier, meaning that the code above would still compile and breech object security. In order to call the GetName function, the author of this code will have to modify it to use a const pointer: const char* pName = localPlayer.GetName(); This modification allows the pointer assignment to compile, but the offending code will still fail to compile: strcpy( pName, “surprise!” ); // ha! nice try With the addition of the const keyword, we’ve prevented our private data from being overwritten, and we’ve done so without sacrificing the savings of returning the address of the player name instead of a www.gameinstitute.com Introduction to C and C++ : Week 3: Page 11 of 47
- copy. The caller still gets a pointer to our private data member, but because it is const, is unable to use it for anything other than read-only operations. Encapsulation You may be wondering why we’re suddenly so concerned with accessibility and security. Why would you have someone on our team who is trying to sabotage your objects? C++ provides the ability to limit access to specific data members and member functions for several reasons, security being just one of them. Another reason is encapsulation. Encapsulation is the practice of hiding how an object works. The idea is that member functions and data members that are specific to the internal workings of a class are made private, and therefore inaccessible to users of the class. A public set of member functions are provided as well, which allow the object to be used, but without exposing any details of the inner workings. This public portion of the class is called an interface. Encapsulation allows a class to be used via a clear and concise interface, without exposing the gory details of how the class works. This accomplishes two purposes: it allows complex functionality to be provided in a simple package, and it makes it possible for the author of the class to modify its inner workings without changing the way the class is used. The Player class, for example, provides an interface composed of four public functions: • SetScore • GetScore • SetName • GetName Users of our class only need to know about these four functions. They don’t need to know about the data members, because they are specific to how the class is implemented. This is precisely why we declared the member functions at the top of the class, and the data members at the bottom. It makes no difference to the compiler, but to a programmer that is looking at the Player class definition with the intention of figuring out how to use it, the interface is prominently displayed at the top, while the data members are tucked away at the bottom (this practice has more of a visual impact with larger classes): class Player { // the public interface is best provided at the top of the class definition public: void SetScore(int s); int GetScore(); void SetName(char* n); const char* GetName(); // the rest of the class is private, and of no concern to users private: char name[80]; int score; }; To demonstrate the power of encapsulation, let’s assume that we have used the Player class in a large game. The game code uses the class to create an array of player objects which are then passed reference to www.gameinstitute.com Introduction to C and C++ : Week 3: Page 12 of 47
- various modules, handling tasks such as game initialization, network services, custom player settings, and a high score screen. The Player class is used in dozens of lengthy and complex source code files. Given its extensive use, it would be a pain to modify the class. Any change to one of the existing interface functions, for example, would “break” the code, causing compilation to fail. Each usage would then have to be found and modified to reflect the interface changes. This could involve hundreds of changes. But to change the implementation of the class—how it works—is easy. Notice that we are currently using a fixed array size of 80 characters. This is a waste of memory (although not a very big one) because most player names are likely to be less than 15 characters. We could simply change the size of the array to 15, but that’s less than ideal. What if a player wants to use a name that’s longer than 15 characters? We don’t want to impose an unreasonable limit just to save few dozen bytes. Instead, we can modify the implementation of the Player class to use dynamic memory, allowing each object to allocate just enough memory for the provided player name. Instead of a fixed array, we can use a pointer, like this: class Player { public: void SetScore(int s); int GetScore(); void SetName(char* n); const char* GetName(); private: char* pName; int score; }; To support this new type, we’ll need to modify the SetName member function to allocate memory dynamically: void Player::SetName(char* n) { assert( n ); int len = strlen( n ); pName = new char[len+1]; strcpy( pName, n ); } This version of SetName uses the strlen function (another standard function, which, like strcpy, is declared in string.h) to retrieve the length of the string provided as n. The new operator is then used to allocate an array that is equal to the name length, plus one extra character for the null terminator. The strcpy function is used to copy the contents of the provided string into the newly allocated array. Now the Player class makes better use of memory, and provides no restriction on player name length at all. And yet the class interface is unchanged. The entire game compiles without further modification, and automatically makes use of the new implementation. The vast majority of the game code hasn’t changed, but the way that it works has. www.gameinstitute.com Introduction to C and C++ : Week 3: Page 13 of 47
- Construtors A constructor is a special function that gets called automatically whenever an object is created. Constructors are typically used to assign initial values to data members so that the new object is in a safe state before it is used. C++ employs a special syntax for constructors: they have the same name as the class. We can add a constructor to the Player class this way: class Player { public: Player(); void SetScore(int s); int GetScore(); private: char* pName; int score; }; This constructor is named Player, just like the class name. Using another name would be legal, but would not result in a constructor. Only constructors are called automatically when instances of a class are created. Unlike global functions and member functions, constructors cannot return values, so no return type precedes the Player constructor declaration above. This limitation means that there is no way to report failures using a return type. As a result, it is generally a bad idea to perform operations that are reasonably likely to fail in a constructor. Attempting to open a file, for example, is best not performed in a constructor because the file may have been moved, deleted, or corrupted prior to execution. For the Player class we can use the constructor to initialize the class data members. Like member functions, constructor bodies can be defined either inside or outside the class definition. Because this constructor performs more than one operation, we’ll opt for the external syntax: Player::Player() { pName = 0; score = 0; } The external syntax requires the use of the scope resolution operator. For constructors this has the odd result of two identical names that appear next to each other, separated by two colons. The Player constructor, as defined above, simply assigns the two data members two zero. Notice that if we were still using the array-based version of Player, this code wouldn’t compile. Despite the fact that arrays are represented as pointers, they cannot be assigned to zero the way that pointers can. The constructor shown above is based on the dynamic memory modification made to the Player class in the previous section. Constructors are special because they are called automatically. In fact, for a class like Player that has a constructor that takes no arguments, there is no way to create an instance of Player without automatically invoking the constructor. This is true regardless of whether the variables are automatic or dynamic: Player autoPlayer; // constructor is called automatically Player* dynPlayer = new Player; // constructor is called automatically www.gameinstitute.com Introduction to C and C++ : Week 3: Page 14 of 47
- In either case, the resulting variable will have data members that are initialized to zero. If an array of players is created, the constructor will be called once for each element: Player playerArray[100]; // constructor is called 100 times, once for each element This is a very nice feature, as it eliminates the possibility of using an un-initialized variable, and frees uses of the class from the vagaries of variable and structure initialization. A constructor that takes no arguments is called a default constructor. Constructors can be written to take arguments. The most common use for constructor arguments is to provide initial values for some or all of the data members. This allows us to provide a constructor for the Player class that takes a player name and initial score: class Player { public: Player(); Player(char* n, int s); void SetScore(int s); int GetScore(); private: char* pName; int score; }; Player::Player(char* n, int s) { pName = 0; SetName( n ); assert( s >= 0 ); score = s; } A class can have any number of constructors, as long as each one has a different argument list. This is possible because of function overloading, as discussed in Lesson 1. In this case we’ve added a constructor that takes a char pointer and an integer for the purposes of providing an initial name and score for the new Player object. The constructor body initializes the data members. The score data member is initialized directly, and the pName data member indirectly—through the use of the SetName member function. Class member functions are free to call other class member functions, and can do so whether they are public or private. In this case we opted to call SetName because the alternative would be to allocate the dynamic memory required to store the player name, and that code has already been written. By calling SetName, we’re re-using that code instead of wasting time writing code that is virtually identical. The new constructor can be used like this: Player player1( “slowpoke”, 100 ); This syntax looks like a function call—which is appropriate, because it is. This code creates a new Player object, and initializes it with the new constructor. The result is an object called player1 with custom values assigned to the internal data members. Notice that we didn’t replace the original constructor. Like www.gameinstitute.com Introduction to C and C++ : Week 3: Page 15 of 47
- regular functions, C++ allows constructors to be overridden. The compiler uses the correct constructor depending on how the object is created: Player defaultPlayer; // calls the default constructor Player customPlayer( “slowpoke”, 100 ); // calls the new constructor In addition to safety, constructors provide a means of dictating how a class is used. For example, we could force anyone using the Player class to provide a player name and score by omitting the default constructor. This would leave the class with only one constructor—one that requires a player name and score. As long as a class provides at least one constructor, objects of that type cannot be created without invoking a constructor. If the only constructor present requires arguments, then providing those arguments is the only way to create an instance of the class. If no constructors are present, new instances of the class will be un-initialized, just as is the case with structures. Destructors The compliment to the constructor is the destructor. A destructor is a special member function that is automatically called when the object is being destroyed. Destructors aren’t always required. Classes that contain only non-pointer data members, for example, don’t typically need destructors because the memory used to represent the object itself is released automatically. But for classes that use external resources such dynamic memory, destructors are often used to release those resources. Our new version of Player, for example, because it allocates dynamic memory to store the player name, needs a destructor so that this memory can be released when the object is destroyed. In its current state the Player class allocates the required memory when the SetName function is called, but never releases it. This is called a memory leak. Memory leaks are specific to memory that is allocated dynamically. It is not possible to leak the memory used by local variables. Memory leaks can’t be detected by the compiler and they don’t generate runtime errors, so they are hard to detect. As a result, memory leaks are very common. It is not unusual for commercial applications, including games, to be shipped with memory leaks. This isn’t a big deal if the offending code allocates just a few hundred bytes or less, but if it allocates large memory buffers, or if the leak is in a function that gets called frequently, the cumulative effect will cause the application to perform poorly, or even crash. Often, memory leaks are found in classes that either don’t have a destructor, or have a destructor that doesn’t release all of the memory that the class uses. We can fix the memory leak in the Player class with a destructor. First, we need to declare it in the class definition: class Player { public: Player(); Player(char* n, int s); ~Player(); void SetScore(int s); www.gameinstitute.com Introduction to C and C++ : Week 3: Page 16 of 47
- int GetScore(); private: char* pName; int score; }; C++ uses the tilde (~) together with the name of the class to indicate a destructor. As a result, destructors look very much like constructors. Like constructors, destructors cannot return values. Unlike constructors, destructors cannot take arguments, so they can’t be overloaded. At most, a class can have one destructor. The Player class definition above declares a destructor, but doesn’t define it. We can define the destructor body internally or externally, but we’ll opt for external: Player::~Player() { delete [] pName; } An external destructor like this one looks very much like the definition for a default constructor (a constructor that doesn’t take any arguments.) The only difference is the tilde. Using the delete operator, this destructor simply releases any dynamic memory that the class is using for player name storage. Notice that the pName data member might be zero. Creating a Player object with the default constructor, for example, and they destroying the object before a player name has been assigned would mean that the pName data member would be initialized to zero (by the default constructor), and then used in that state by the destructor. This is legal. C++ implements the delete operator in such a way that passing a pointer that points to zero will have no effect. Now, regardless of how objects of the Player type are created, any memory allocated for the player name will be released when the object is destroyed. This code demonstrates the case where a Player object is created as an automatic variable: void TestFunc() { Player p; p.SetName( “slowpoke” ); // this call allocates dynamic memory // the object ‘p’ is destroyed automatically when this function returns // the Player destructor will be called, releasing the dynamic memory } Likewise, player objects created dynamically don’t leak memory anymore either, assuming that we remember to destroy the player object itself with delete. In the code below, the lifespan of the player object is controlled by two functions, one that is called during game startup, and the other during game shutdown. The player object exists for the duration of the game: Player* localPlayer = 0; // global pointer void DoStartup() { localPlayer = new Player; localPlayer->SetName( “unnamed player” ); www.gameinstitute.com Introduction to C and C++ : Week 3: Page 17 of 47
- // initialize other game objects } void DoShutdown() { delete localPlayer; // delete other game objects } This example makes use of a global Player pointer, allowing more than one function to access the object. The DoStartup function assigns this pointer using the new operator, creating a new instance of the Player class. The SetName member function is then called with a default player name. Internally to the Player object, this results in a dynamic memory allocation, but that’s of no concern to users of the Player class. The DoShutdown function is designed to perform the release of objects used by the game. This function uses the delete operator to destroy the player object created earlier. This command results in a call to the class destructor, which uses delete again, this time to release the memory used to store the player name. Unfortunately, the addition of a destructor to the Player class has fixed the memory leak, but only for the simple case where the player name is set once. This class will still leak memory if the SetName function is called twice. To fix this leak we need to modify the SetName member function. As a reminder, this is how it looks currently: void Player::SetName(char* n) { assert( n ); int len = strlen( n ); pName = new char[len+1]; strcpy( pName, n ); } The problem with this version is that it assumes that pName hasn’t already been assigned with a previous call. The address stored in pName is simply overwritten as new memory is allocated with the call to new. This problem can be fixed by first using the delete operator to release any existing memory: void Player::SetName(char* n) { assert( n ); delete [] pName; int len = strlen( n ); pName = new char[len+1]; strcpy( pName, n ); } This modification works whether or not pName was assigned to point to a player name previously. If not, then pName will be zero, which delete will simply ignore. If another name has been assigned, this www.gameinstitute.com Introduction to C and C++ : Week 3: Page 18 of 47
- modification will release the memory used previously before allocating a new array. Now the Player class can handle any of the three cases: • No name is assigned at all • One name is assigned • Multiple names are assigned To demonstrate this final case, let’s revisit the startup/shutdown example, and add a new function: Player* localPlayer = 0; // global pointer void DoStartup() { localPlayer = new Player; localPlayer->SetName( “unnamed player” ); // initialize other game objects } void GetActualPlayerName() { char realName[80]; // code to get name from user assert( localPlayer ); // This call deletes the memory used to store “unnamed player”, // and allocates a new character array for the name stored // in the realName array. localPlayer->SetName( realName ); } void DoShutdown() { delete localPlayer; // delete other game objects } Now we’ve added a third function, which may or may not get called, that overrides the default player name assigned in the startup code. This second call to SetName deletes the memory used for the default name, and allocates a new array for the storage of the player’s name. The code above does not constitute a complete program. For one thing, there is no main function. This code demonstrates how an object might be used in a game when the object is required for longer than the execution of a single function. Although this isn’t a complete program, it does hint at the fundamental layout for game design because games require (often lengthy) startup procedures, and these functions are typically matched to a function that performs shutdown procedures. We’ll talk about this in detail in the next lesson. www.gameinstitute.com Introduction to C and C++ : Week 3: Page 19 of 47
- The this Pointer In order to continue learning about objects, it’s necessary to introduce the fact that C++ provides a keyword that is valid within the scope of every structure and class, which indicates the address of the current object. The this keyword is a pointer to the current object. The type of this varies; it is always the type of the class within which this is being used. We’ll talk about some cases where using this is necessary soon, but for now it is enough to know that this is present, and that it can be used as a means of accessing object members. For example, anytime a data member or member function is used, it can be prefixed with this, like so: void Player::SetScore(int s) { score = s; this->score = s; } Both of the statements in this function accomplish the same effect: they both assign the score data member. In this case there’s no reason to use this, but in the next section we’ll present a case where the use of this is required. The Assignment Operator C++ allows the assignment operator (=) to be used to assign the data from one variable to another. This is true for intrinsic data types, structures, and classes (but not arrays.) For example: // making a copy of an intrinsic type: int a, b = 44; a = b; // ‘a’ is now 44 struct Vector { float x, y; }; // making a copy of a structure Vector v1, v2 = { 1.0f, 1.0f }; v1 = v2; // ‘v1’ is now equal to ‘v2’ ( v1.x == 1.0f and v1.y == 1.0f ) // making a copy of a class Player p1, p2( “slowpoke” ); p1 = p2; // ‘p1’ is now equal to ‘p2’ (it has “slowpoke” for a player name) This is possible because, as long as the variables on either side of the assignment operator are of the same type, C++ generates code that copies all of the data in the right-hand variable to the left-hand variable. This works fine for intrinsic types, but is a potential source of trouble with structures and classes— particularly if the structure or class contains pointers. For the version of the Player class that we defined earlier that used a fixed array of 80 characters to store the player name, the assignment operator can be used to assign variables with no unwanted side effects. But for the later version that uses a char pointer, the result of using the assignment operator is that the two objects will use the same instance of dynamic memory. The assignment operator copies data from www.gameinstitute.com Introduction to C and C++ : Week 3: Page 20 of 47
CÓ THỂ BẠN MUỐN DOWNLOAD
-
Giáo trình C toàn tập
298 p |
384 |
228
-
Giáo trình C++
65 p |
592 |
180
-
Giáo trình C++ / Chương 6: Lập trình hướng đối tượng
12 p |
163 |
86
-
Giáo trình C++/ Chương 3: Lệnh
13 p |
160 |
76
-
Giáo trình C++ - Đại Học Bách Khoa (phần 2)
9 p |
121 |
38
-
Giáo trình C++/ Chương 8: Tái định nghĩa
24 p |
106 |
31
-
Giáo trình C++ Đại Học Bách Khoa (phần 5)
0 p |
71 |
28
-
Giáo trình C++ - Đại Học Bách Khoa (phần 3)
13 p |
75 |
27
-
Giáo trình C++/ Chương 9: Thừa kế
20 p |
92 |
26
-
Giáo trình C++ - Đại Học Bách Khoa (phần 4)
0 p |
102 |
25
-
Giáo trình C++/ Chương 1: Mở đầu
15 p |
82 |
22
-
Giáo trình C++ - Đại Học Bách Khoa (phần 6)
0 p |
69 |
21
-
Giáo trình C++ - Đại Học Bách Khoa (phần 7)
0 p |
71 |
18
-
Giáo trình C++ - Đại Học Bách Khoa (phần 8)
0 p |
48 |
13
-
Giáo trình C++_hàm và chương trình
62 p |
57 |
13
-
Giáo trình C++_khái niệm cơ bản
19 p |
72 |
12
-
Giáo trình C++_Cấu trúc điều khiển và dữ liệu kiểu mạng
42 p |
58 |
9
-
Giáo trình C++_Kiểu dữ liệu biểu thức và câu lệnh
21 p |
49 |
8

Server: Apache/2.2.31 (CentOS)

Set-Cookie: TLDEVNamespace=vud40nm9d8ofe29omg3b278004; path=/; domain=.tailieu.vn; HttpOnly


markdown:
# Luận văn tốt nghiệp: Tìm hiểu khai thác SQL Server và sử dụng nó để giải quyết bài toán quản lý dân cư
Chia sẻ: Hoang Nhan | Ngày: | Loại File: PDF | Số trang:84
lượt xem 254
download
![](http://image1.tailieu.vn/document/thumbnail/2009/20091120/nguyen5/80x100/tim_hieu_sql_server_0714.jpg)
##
Luận văn tốt nghiệp: Tìm hiểu khai thác SQL Server và sử dụng nó để giải quyết bài toán quản lý dân cư
[Vui lòng tải xuống để xem tài liệu đầy đủ](javascript:void(0);)
Download
![](http://static1.tailieu.vn/b2013az/templates/version1/default/images/down16x21.png)
Cơ sở dữ liệu và quản trị cơ sở dữ liệu là một trong những vấn đề cốt lõi của tin học. Xét cho cùng khi ứng dụng tin học để giải quyết các bài toán thì người ta phải giải quyết vấn đề xây dựng cơ sở dữ liệu và xây dựng thuật toán xử lý chúng. Khi cơ sở dữ liệu càng lớn nhu cầu xử lý phức tạp, yêu cầu bảo mật càng cao thì vấn đề quản trị cơ sở dữ liệu càng phức tạp. Vì vậy các mục tiêu của đề án này là tìm...
Bình luận(0)
[Đăng nhập để gửi bình luận!](javascript:void(0);)
##
Nội dung Text: Luận văn tốt nghiệp: Tìm hiểu khai thác SQL Server và sử dụng nó để giải quyết bài toán quản lý dân cư
- ------ Luận văn tốt nghiệp Tìm hiểu khai thác SQL Server và sử dụng nó để giải quyết bài toán quản lý dân cư
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT §Æt vÊn ®Ò C¬ së d÷ liÖu vµ qu¶n trÞ c¬ së d÷ liÖu lµ mét trong nh÷ng vÊn ®Ò cèt lâi cña tin häc. XÐt cho cïng khi øng dông tin häc ®Ó gi¶i quyÕt c¸c bµi to¸n th× ng−êi ta ph¶i gi¶i quyÕt vÊn ®Ò x©y dùng c¬ së d÷ liÖu vµ x©y dùng thuËt to¸n xö lý chóng. Khi c¬ së d÷ liÖu cµng lín nhu cÇu xö lý phøc t¹p, yªu cÇu b¶o mËt cµng cao th× vÊn ®Ò qu¶n trÞ c¬ së d÷ liÖu cµng phøc t¹p. V× vËy c¸c môc tiªu cña ®Ò ¸n nµy lµ t×m hiÓu khai th¸c SQL Server vµ sö dông nã ®Ó gi¶i quyÕt bµi to¸n qu¶n lý d©n c−. Tõ môc tiªu cña ®Ò ¸n chóng ta thÊy r»ng néi dung cña ®Ò ¸n gåm cã hai phÇn c¬ b¶n: 1. T×m hiÓu khai th¸c SQL Server. 2. Gi¶i quyÕt bµi to¸n qu¶n lý d©n c− trªn SQL Server. Lý do chän Microsoft SQL Server: • XuÊt ph¸t tõ ®Æc ®iÓm bµi to¸n kÝch th−íc lín, ph©n t¸n, ®a ng−êi sö dông. • MS SQL Server lµ hÖ qu¶n trÞ c¬ së d÷ liÖu hç trî tèt víi l−îng d÷ liÖu lín, cho phÐp ng−êi sö dông theo m« h×nh Client/Server. • MS SQL Server tiÖn dông trong viÖc ph©n t¸n tra cøu d÷ liÖu nhanh. • MS SQL Server hç trî m¹nh víi d÷ liÖu ph©n t¸n. MS SQL Server ch¹y trªn m«i tr−êng Win NT (Server) vµ Win 9.X, Win 2000 (Client), ... SQL Server lµ mét trong nh÷ng hÖ phÇn mÒm tiÖn lîi vµ hiÖu qu¶ trong viÖc ph¸t triÓn c¸c øng dông c¬ së d÷ liÖu lín, ph©n t¸n thÝch hîp cho c¬ quan, tæ chøc, ®Þa ph−¬ng, ... MS SQL Server hç trî tèt trong qu¶n lý xö lý ®ång nhÊt, b¶o mËt d÷ liªu theo m« h×nh Client/Server trªn m¹ng. Víi m¸y chñ cã MS SQL Server cã thÓ qu¶n trÞ nhiÒu Server víi tªn kh¸c nhau (c¸c Server lµ hÖ qu¶n trÞ c¸c c¬ së d÷ liÖu riªng cña m×nh), vµ nhãm c¸c Server (Server group). -1-
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT Trªn mçi Server th«ng th−êng cã nhiÒu c¬ së d÷ liÖu (Databases). Mçi c¬ së d÷ liÖu chøa mét sè ®èi t−îng c¬ së d÷ liÖu lµ c¸c b¶ng, c¸c khung nh×n (view), hay c¸c thñ tôc truy vÊn (query). Mçi c¬ së d÷ liÖu sÏ chøa danh s¸ch nh÷ng ng−êi sö dông c¬ së d÷ liÖu ®ã, hä ®−îc trao mét sè quyÒn nhÊt ®Þnh ®Ó truy nhËp ®Õn tõng ®èi t−îng. Ng−êi sö dông cã quyÒn cao nhÊt víi mét c¬ së d÷ liÖu chÝnh lµ ng−êi t¹o ra c¬ së d÷ liÖu ®ã (Owner). Chñ nh©n c¬ së d÷ liÖu (Database Owner) lµ ng−êi sö dông t¹o nªn c¬ së d÷ liÖu, mçi c¬ së d÷ liÖu cã mét chñ nh©n, chñ nh©n c¬ së d÷ liÖu cã ®Çy ®ñ ®Æc quyÒn bªn trong c¬ së d÷ liÖu vµ x¸c ®Þnh cung cÊp kh¶ n¨ng truy cËp tíi ng−êi kh¸c. Trong c¬ së d÷ liÖu cña m×nh ng−êi sö dông ®−îc giíi thiÖu nh− lµ DBO trong c¬ së d÷ liÖu kh¸c, Chñ nh©n c¬ së d÷ liÖu lµ ®−îc biÕt ®Õn bëi tªn sö dông c¬ së d÷ liÖu cña hä. Chñ nh©n cña c¸c ®èi t−îng c¬ së d÷ liÖu (Database Object Owner) lµ ng−êi sö dông t¹o ra c¬ së d÷ liÖu (c¸c b¶ng, c¸c chØ sè, c¸c khung nh×n, mÆc ®Þnh, c¸c trigger, c¸c quy t¾c, vµ c¸c thñ tôc ). Mçi c¬ së d÷ liÖu cã duy nhÊt mét ng−êi t¹o ra. Chñ nh©n cña c¸c ®èi t−îng c¬ së d÷ liÖu lµ tù ®éng g¸n quyÒn cho phÐp toµn bé trªn ®èi t−îng c¬ së d÷ liÖu. Chñ nh©n cña ®èi t−îng c¬ së d÷ liÖu cã thÓ trao quyÒn cho phÐp tíi ng−êi sö dông kh¸c, tíi ®èi t−îng sö dông. SQL Server l−u tr÷ c¬ së d÷ liÖu trªn c¸c thiÕt bÞ kh¸c nhau, mçi thiÕt bÞ cã thÓ n»m trªn ®Üa cøng, mÒm, b¨ng tõ, cã thÓ n»m trªn nhiÒu ®Üa. C¬ së d÷ liÖu cã thÓ ®−îc l−u tr÷ trªn mét hay nhiÒu thiÕt bÞ. Còng cã thÓ më réng kÝch th−íc thiÕt bÞ vµ thiÕt bÞ l−u tr÷ mét c¬ së d÷ liÖu. SQL Server cho phÐp qu¶n trÞ víi tÖp d÷ liÖu lín tíi 32 TB (Tetabyte). SQL Server ®· kÕ thõa cïng Windows NT t¹o nªn mét hÖ thèng b¶o mËt tèt qu¶n trÞ user, Server, vµ nh÷ng tiÖn Ých cña Windows NT. -2-
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT Ch−¬ng I CÊu tróc MS SQL Server I. Nhãm Server vµ Server I.1 T¹o nhãm Server B¹n cã thÓ t¹o nhãm Server víi SQL Server Enterprise Manager vµ ®Æt Server cña b¹n trong nhãm Server. Nhãm Server cung cÊp h−íng thÝch hîp ®Ó tæ chøc sè l−îng lín Server vµo trong mét nhãm. C¸c b−íc t¹o mét nhãm Server míi (Enterprise manager) 1. Trªn menu Tools, chän Register SQL Server. 2. Trong hép tho¹i Register SQL Server Properties, trong hép Server, h·y nhÊp browse(...) ®Ó truy cËp vµo mét danh s¸ch c¸c Server trªn m¹ng. 3. Trong hép Server Group, nhÊp browse(...). 4. Trong hép name, nhËp vµo tªn mét nhãm Server. 5. Trong hép level, h·y nhÊp: • Top level group ®Ó t¹o mét nhãm Server míi ë møc cao nhÊt. • Sub-group of, råi nhÊp mét nhãm Server ®Ó lËp danh s¸ch nhãm Server míi trong mét nhãm Server ®ang cã. -3-
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT I.2 C¸ch ®¨ng ký mét Server 1. Trªn menu Tools, chän Register SQL Server. 2. Trong hép tho¹i Register SQL Server Properties, trong hép Server, h·y nhËp tªn cña SQL Server ®Ó ®¨ng ký, hoÆc nhÊp browse(...) ®Ó truy cËp vµo mét danh s¸ch c¸c Server trªn m¹ng. 3. Trong hép Connect, h·y nhÊp: Use SQL Server Authentication ®Ó nçi vµo SQL Server víi Microsoft Windows NT login ID password cña b¹n. Use Windows NT Server Authentication, råi nhÊp mét tªn login vµ mét password mµ Server cã thÓ nhËn biÕt. ®Ó bæ xung mét líp cña møc an toµn h·y chän Always promt for login name password. 4. Trong danh s¸ch Server Group, h·y nhÊp tªn cña SQL Server mµ ë ®ã b¹n muèn ®−a vµo Server ®· ®−îc ®¨ng ký, hoÆc nhÊp browse(...) ®Ó t¹o mét nhãm Server míi. II. C¸c thiÕt bÞ vµ c¬ së d÷ liÖu hÖ thèng C¬ së d÷ liÖu lµ tËp hîp d÷ liÖu, b¶ng d÷ liÖu vµ c¸c ®èi t−îng c¬ së d÷ liÖu kh¸c cã trËt tù vµ ®−îc giíi thiÖu ®Ó ®¸p øng mét môc ®Ých râ rµng, nh− lµ ®iÒu kiÖn thuËn lîi cña viÖc t×m kiÕm x¾p xÕp vµ tæ chøc l¹i d÷ liÖu. C¬ së d÷ liÖu ®−îc l−u tr÷ trªn c¸c thiÕt bÞ. -4-
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT ThiÕt bÞ (Device) lµ file hÖ ®iÒu hµnh trong c¬ së d÷ liÖu ®−îc l−u tr÷. Mét c¬ së d÷ liÖu cã thÓ l−u tr÷ trªn mét vµi thiÕt bÞ. SQL Server cã hai lo¹i thiÕt bÞ: ThiÕt bÞ c¬ së d÷ liÖu nã l−u tr÷ c¬ së d÷ liÖu vµ thiÕt bÞ sao l−u, l−u tr÷ kh«i phôc c¬ së d÷ liÖu. Khi SQL Server ®−îc cµi ®Æt ch−¬ng tr×nh cµi ®Æt t¹o ra MASTER, MSDBDATA, vµ thiÕt bÞ c¬ së d÷ liÖu MSDBLOG. Nã còng t¹o ra c¬ së d÷ liÖu Master, Model, Tempdb, Pubs vµ ®Æt chóng trªn thiÕt bÞ c¬ së d÷ liÖu MASTER, h¬n n÷a nã còng t¹o ra c¬ së d÷ liÖu Msdb vµ l−u tr÷ trªn thiÕt bÞ c¬ së d÷ liÖu MSDBDATA vµ n¬i thùc hiÖn Msdb log on thiÕt bÞ MSDBLOG. II.1 C¬ së d÷ liÖu chÝnh (Master database) Khi SQL Server ®−îc cµi ®Æt, ch−¬ng tr×nh cµi ®Æt t¹o ra thiÕt bÞ c¬ së d÷ liÖu MASTER råi t¹o ra c¬ së d÷ liÖu chÝnh vµ ®Æt nã trªn thiÕt bÞ ( device ). Ng−êi ®iÒu khiÓn sö dông c¬ së d÷ liÖu chÝnh vµ thao t¸c toµn bé SQL Server. Nã kiÓm tra vµ gi÷ l¹i sù tÝnh to¸n cña ng−êi sö dông, ng−êi sö dông tõ xa. Server phôc vô tõ xa cã thÓ t−¬ng t¸c víi tiÕn tr×nh ®ang diÔn ra, cã kh¶ n¨ng ®Þnh cÊu h×nh biÕn m«i tr−êng, hÖ thèng th«ng b¸o lçi c¬ së d÷ liÖu trªn SQL Server, ph©n ph¸t kh«ng gian l−u tr÷ cho mçi c¬ së d÷ liÖu, b¨ng vµ ®Üa s½n cã trªn hÖ thèng vµ c¸c kho¸ hiÖn hµnh. SQL Server còng cã thÓ thªm ®èi t−îng ng−êi sö dông tíi c¬ së d÷ liÖu chÝnh nh−ng nã kh«ng ®−îc t¹o ra ®èi t−îng trong c¬ së d÷ liÖu chÝnh dïng cho toµn bé hÖ thèng qu¶n trÞ. SQL Server thiÕt lËp vµ cho phÐp trong toµn bé c¬ së d÷ liÖu chÝnh mµ phÇn lín ng−êi sö dông kh«ng thÓ t¹o ra ®èi t−îng. B¹n cã thÓ ng¨n c¶n ng−êi sö dông tõ ®èi t−îng t¹o ra trong c¬ së d÷ liÖu chÝnh b»ng c¸ch thay ®æi ngÇm ®Þnh cña ng−êi sö dông c¬ së d÷ liÖu. Tuy nhiªn ng−êi qu¶n trÞ hÖ thèng ngÇm ®Þnh c¬ së d÷ liÖu nªn gi÷ nguyªn c¬ së d÷ liÖu chÝnh. -5-
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT II.2 M« h×nh c¬ së d÷ liÖu (Model Database) M« h×nh c¬ së d÷ liÖu chøa ®ùng b¶ng hÖ thèng, yªu cÇu cho mçi ng−êi sö dông c¬ së d÷ liÖu. Nã còng cã thÓ ®−îc söa ®æi theo h−íng tuú biÕn cÊu tróc míi t¹o ra c¬ së d÷ liÖu còng nh− mäi thay ®æi b¹n t¹o ra m« h×nh ®−îc ph¶n ¸nh trong mçi c¬ së d÷ liÖu míi. Cã mét vµi thay ®æi chung t¹o ra m« h×nh: • Thªm vµo lo¹i d÷ liÖu ng−êi sö dông, c¸c rµng buéc, c¸c quy t¾c hoÆc ngÇm ®Þnh. • Thªm vµo ng−êi sö dông nµo lµ ®−îc truy cËp toµn bé c¬ së d÷ liÖu trªn SQL Server. • Lùa chän cÊu h×nh c¬ së d÷ liÖu ( nh− lµ select into/bulkcopy), thiÕt lËp trong m« h×nh c¬ së d÷ liÖu. II.3 C¬ së d÷ liÖu Msdb (Msdb Database) C¬ së d÷ liÖu Msdb hç trî thùc hiÖn SQL vµ cung cÊp vïng l−u tr÷ c¸c th«ng tin lËp biÓu trong thêi gian cµi ®Æt phÇn mÒn Server. Ch−¬ng tr×nh cµi ®Æt tù ®éng t¹o ra hai device ( 2MB & 1MB ) trªn æ ®Üa t−¬ng tù nh− lµ c¬ së d÷ liÖu chÝnh råi ®Æt c¬ së d÷ liÖu Msdb trªn 2MB device ( MSDBDATA ) vµ thùc hiÖn nhËp vµo device 1MB ( MSDBLOG ). II.4 C¬ së d÷ liÖu Tempdb (Tempdb Database) C¬ së d÷ liÖu Tempdb lµ chia sÎ kh«ng gian lµm viÖc sö dông bëi c¬ së d÷ liÖu trªn SQL Server. C¸c b¶ng t¹m thêi cña ng−êi sö dông lµ mÊt ®i tõ Tempdb khi ng−êi sö dông hiÖn hµnh tho¸t khái SQL Server hoÆc trong thêi gian truy l¹i tõ sù dõng l¹i cña hÖ thèng. Thñ tôc l−u tr÷ c¸c b¶ng t¹m thêi lµ mÊt ®i khi thñ tôc tho¸t ra. B¶ng t¹m thêi còng cã thÓ mÊt ®i tr−íc khi kÕt thóc phiªn. KÝch th−íc ngÇm ®Þnh cña Tempdb lµ 2MB. Ho¹t ®éng nµo ®ã theo sau cã thÓ cÇn thiÕt t¹o nªn ®Ó t¨ng kÝch th−íc cña Tempdb: B¶ng t¹m thêi lín. Ho¹t ®éng cã ý nghÜa trªn b¶ng t¹m thêi. S¾p xÕp hoÆc nhiÒu s¾p xÕp lín s¶y ra trong b¶ng cïng mét lóc. Truy vÊn con vµ tËp hîp l¹i víi GROUP BY. Sè l−îng lín cña Open cursor. -6-
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT II.5 C¬ së d÷ liÖu Pubs (Pubs Database) C¬ së d÷ liÖu Pubs lµ c¬ së d÷ liÖu lÊy mÉu cung cÊp nh− lµ c«ng cô nghiªn cøu. C¬ së d÷ liÖu pubs lµ c¬ së cña phÇn lín c¸c vÝ dô trong t− liÖu cña Microsoft SQL Server. C¬ së d÷ liÖu mÉu ®−îc miªu t¶ trong Microsoft SQL Server Transact-SQL Referrence. NÕu c¬ së d÷ liÖu Pubs kh«ng yªu cÇu cho môc ®Ých nghiªn cøu, b¹n cã thÓ kh«ng cÇn nã. II.6 C¸c b¶ng hÖ thèng (System Tables) B¶ng lµ mét tËp hîp c¸c hµng (Record) mµ cã liªn quan ®Õn c¸c cét ( Fields). C¬ së d÷ liÖu chÝnh vµ ng−êi sö dông c¬ së d÷ liÖu gåm cã c¸c b¶ng hÖ thèng th«ng tin vÒ toµn bé SQL Server vµ mçi ng−êi sö dông c¬ së d÷ liÖu. Toµn bé SQL Server cung cÊp b¶ng trong c¬ së d÷ liÖu chÝnh ®−îc xem xÐt trong b¶ng hÖ thèng. Mçi ng−êi sö dông c¬ së d÷ liÖu t¹o ra b¶ng hÖ thèng. C¬ së d÷ liÖu chÝnh vµ b¶ng hÖ thèng ®−îc t¹o ra khi cµi ®Æt SQL Server. Trong b¶ng hÖ thèng ng−êi sö dông c¬ së d÷ liÖu tù ®éng t¹o ra kho c¬ së d÷ liÖu. Tªn cña phÇn lín c¸c b¶ng hÖ thèng ®Òu b¾t ®Çu víi SYS. Sù cho phÐp b¶ng hÖ thèng (Permission for System Table) Sù cho phÐp lµ giÊy phÐp ®¶m b¶o cho ng−êi sö dông thùc hiÖn ho¹t ®éng nµo ®ã trªn ®èi t−îng c¬ së d÷ liÖu nµo ®ã hoÆc sö dông c©u lÖnh nµo ®ã. Cho phÐp sö dông b¶ng hÖ thèng lµ ®−îc ®iÒu khiÓn bëi c¬ së d÷ liÖu cña chÝnh m×nh (owner). SQL Server cµi ®Æt ch−¬ng tr×nh thiÕt lËp cho phÐp toµn bé ng−êi sö dông cã thÓ ®äc hÖ thèng b¶ng ngo¹i trõ mét vµi tr−êng. Truy vÊn b¶ng hÖ thèng (Querying the System Table) B¶ng hÖ thèng cã thÓ yªu cÇu ®Õn c¸c b¶ng kh¸c, vÝ dô nh− c©u lÖnh sau cho trë l¹i tªn toµn bé b¶ng hÖ thèng trong c¬ së d÷ liÖu. SELECT Name FROM SysObject WHERE Type = ‘S’ SQL Server cã thñ tôc l−u tr÷ hÖ thèng cung cÊp lèi t¾t cho truy vÊn hÖ thèng b¶ng. -7-
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT II.7 Thñ tôc l−u tr÷ hÖ thèng (System Store Procedure) Thñ tôc l−u tr÷ hÖ thèng lµ tËp hîp tr−íc khi biªn dÞch c©u lÖnh Transact-SQL. NhiÒu thñ tôc l−u tr÷ hÖ thèng cã s½n cho viÖc qu¶n trÞ SQL Server vµ hiÓn thÞ th«ng tin vÒ c¬ së d÷ liÖu vµ ng−êi sö dông. PhÇn lín tªn thñ tôc l−u tr÷ hÖ thèng b¾t ®Çu víi SP_. Thñ tôc l−u tr÷ hÖ thèng x¸c ®Þnh vÞ trÝ trong c¬ së d÷ liÖu chÝnh vµ chÝnh bëi ng−êi qu¶n trÞ hÖ thèng. Nh−ng nhiÒu thñ tôc l−u tr÷ hÖ thèng cã kh¶ n¨ng ch¹y tõ bÊt kú c¬ së d÷ liÖu nµo. NÕu thñ tôc l−u tr÷ hÖ thèng thùc hiÖn trong c¬ së d÷ liÖu kh¸c víi c¬ së d÷ liÖu chÝnh th× nã ®ang lµm viÖc trªn hÖ thèng b¶ng trong c¬ së d÷ liÖu tõ b¶ng hÖ thèng ®−îc thùc hiÖn. Thªm vµo thñ tôc l−u tr÷ hÖ thèng vµ thñ tôc l−u tr÷ më réng ®−îc cµi ®Æt víi SQL Server. Thñ tôc l−u tr÷ më réng cung cÊp thªm chøc n¨ng cho SQL Server, cung cÊp b»ng c¸ch n¹p ®éng vµ thùc hiÖn chøc n¨ng víi th− viÖn liªn kÕt ®éng (DLL=Data Library Link) g¾n liÒn víi chøc n¨ng më réng SQL Server. Ho¹t ®éng bªn ngoµi SQL Server cã thÓ dÔ dµng kÝch ho¹t vµ th«ng tin më réng trë l¹i SQL Server. M· tr¹ng th¸i trë l¹i & tham sè ®Çu ra lµ còng ®−îc hç trî. SQL Server bao gåm hÖ thèng l−u tr÷ thñ tôc cã thÓ thªm vµo vµ xo¸ ®i thñ tôc l−u tr÷ më réng, cung cÊp th«ng tin vÒ thñ tôc l−u tr÷ më réng. H¬n thÕ SQL Server cung cÊp sè l−îng thñ tôc l−u tr÷ hÖ thèng, thñ tôc l−u tr÷ hÖ thèng kh¸c cã thÓ t¹o ra bëi ng−êi lËp tr×nh sö dông dÞch vô d÷ liÖu më cña Microsoft. II.8 ThiÕt lËp kÝ tù vµ trËt tù s¾p xÕp (Character Sets & Sort Order) ThiÕt lËp kÝ tù x¸c ®Þnh lo¹i kÝ tù mµ SQL Server chÊp nhËn trong c¬ së d÷ liÖu. ThiÕt lËp kÝ tù lµ thiÕt lËp 256 ch÷ c¸i, ch÷ sè vµ c¸c biÓu t−îng ®Æc tr−ng cho mét quèc gia hay mét ng«n ng÷. Cã thÓ in ra 128 kÝ tù ®Çu tiªn gièng nh− ®¹i diÖn cho toµn bé thiÕt lËp kÝ tù. 128 kÝ tù sau ®«i khi ®−îc nh¾c ®Õn nh− lµ kÝ tù më réng. B¹n nªn sö dông thiÕt lËp kÝ tù cho c¶ Client & Server hoÆc kÕt qu¶ cña b¹n cã thÓ thay ®æi. Tuy nhiªn nÕu c¬ së d÷ liÖu cña b¹n sö dông 128 kÝ tù ban ®Çu cña tËp hîp kÝ tù, nã kh«ng t¹o nªn sù kh¸c biÖt nµo víi thiÕt lËp kÝ tù b¹n sö dông bëi v× 128 kÝ tù ®Çu tiªn ph¶i gièng nh− toµn bé tËp kÝ tù. TrËt tù s¾p xÕp thiÕt lËp c¸c quy t¾c x¸c ®Þnh SQL Server so s¸nh vµ giíi thiÖu d÷ liÖu trong sù h−ëng øng tíi c¬ së d÷ liÖu truy vÊn nh− thÕ nµo ?. TrËt tù s¾p xÕp x¸c ®Þnh trËt tù d÷ liÖu lµ giíi thiÖu tr¶ lêi c©u lÖnh SQL Server gåm: GROUP BY, ORDER BY & DISTINT. TrËt tù s¾p xÕp -8-
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT còng ®Þnh râ truy vÊn nµo ®ã lµ ®−îc gi¶i quyÕt nh− lµ truy vÊn: WHERE & DISTINT. ThiÕt lËp kÝ tù vµ trËt tù s¾p xÕp cung cÊp cho toµn bé Server. B¹n kh«ng thÓ cã c¬ së d÷ liÖu kh¸c nhau víi thiÕt lËp kÝ tù kh¸c nhau hoÆc trËt tù s¾p xÕp trªn Server. III. C¸c tiÖn Ých, dÞch vô cña SQL Server III.1 Qu¶n lý c¸c c«ng cô vµ c¸c tiÖn Ých (Administrative Tools & Utility) C«ng cô ®å ho¹ M« t¶ (Graphical Tools) (Descrition) Sö dông cÊu h×nh Server, b¹n cã thÓ sö dông SQL setup ch−¬ng tr×nh cµi ®Æt ®Ó thay ®æi c¸c tuú chän hç trî m¹ng. Thªm vµo c¸c ng«n ng÷, x©y dùng l¹i c¬ së d÷ liÖu chÝnh, thay ®æi thiÕt lËp kÝ tù vµ trËt tù s¾p xÕp, thiÕt lËp c¸c tuú chän an toµn vµ gì bá SQL Server. SQL Server Sö dông c©u lÖnh Start, Pause, Continue & Stop Manager SQL Server vµ SQL Execute. ISQL/w Cho phÐp b¹n nhËp lÖnh Transact-SQL vµ thñ tôc l−u tr÷ hÖ thèng trong giao diÖn truy vÊn ®å ho¹. ISQL/w còng cung cÊp kh¶ n¨ng cho ph©n tÝch truy vÊn ®å ho¹. SQL Security Cho phÐp qu¶n lý user account víi SQL Server mµ Manager sö dông an toµn thèng nhÊt víi Windows NT. SQL Enterprise Cung cÊp dÔ dµng, qu¶n lý xÝ nghiÖp réng tõ Manager Server hoÆc Workstation. Nã cho phÐp b¹n thùc hiÖn nhiÖm vô qu¶n trÞ hÖ thèng sö dông giao diÖn ®å ho¹. B¹n cã thÓ ®Æt cÊu h×nh Server, qu¶n trÞ c¬ së d÷ liÖu vµ ®èi t−îng c¬ së d÷ liÖu, lËp thêi biÓu cho c¸c biÕn cè (event), ®Þnh cÊu h×nh vµ qu¶n lý sù t¸i t¹o vµ cã thÓ lµm ®−îc h¬n thÕ n÷a. SQL Transact Cung cÊp mét c¸ch dÔ dµng, ®å ho¹ theo c¸ch Manager truyÒn c¸c ®èi t−îng vµ d÷ liÖu tõ Server tíi n¬i kh¸c. SQL Performance TÝch hîp víi Windows NT thùc hiÖn ®iÒu khiÓn Monitor víi SQL Server, ... SQL Server Book Cung cÊp trùc tuyÕn tíi Microsoft SQL Server, -9-
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT Online thiÕt lËp t− liÖu bao gåm søc m¹nh vµ kh¶ n¨ng t×m kiÕm dÔ dµng ®èi víi ng−êi sö dông. Microsoft ODBC Lµ mét file trî gióp trùc tuyÕn cung cÊp th«ng tin SQL Server driver vÒ Microsoft ODBC SQL Server driver. SQL Distribute Lµ mét file trî gióp trùc tuyÕn hiÓn thÞ SQL Manager Object Distribute Manager Object. SQL Client ThiÕt lËp mÆc ®Þnh Net-Library & Server nèi tíi Configuration th«ng tin trªn Client. Nã còng cã thÓ hiÓn thÞ BD- Utility Library vµ kiÓm tra cho nhiÒu b¶n sao cña DB- Library & Net-Library trong ®−êng dÉn cña b¹n. III.2 SQL Server Book Online Trong thêi gian cµi ®Æt Server software hoÆc Client software 32 bit hoÆc 16 bit m¸y tÝnh dùa vµo nÒn Windows. Ch−¬ng tr×nh cµi ®Æt ®−a ra cho b¹n c¸c cµi ®Æt tù chän SQL Server Book Online. SQL Server Book Online cung cÊp truy cËp trªn mµn h×nh tíi toµn bé thiÕt lËp t− liÖu SQL Server. §¸ng chó ý vÒ søc m¹nh ®Æc biÖt lµ nã cã kh¶ n¨ng t×m kiÕm ®Çy ®ñ v¨n b¶n mµ cho phÐp t×m nhanh c¸c tõ hoÆc ®o¹n v¨n, b¹n còng cã thÓ t×m kiÕm toµn bé v¨n b¶n hoÆc th«ng qua lùa chän s¸ch hoÆc c¸c chñ ®Ò. III.3 DÞch vô cña SQL Server SQL Server Service Manager sö dông ®Ó b¾t ®Çu (start), t¹m dõng (pause) vµ dõng (stop) c¸c thµnh phÇn Microsoft SQL Server trªn Server. C¸c thµnh phÇn ch¹y nh− lµ dÞch vô trªn Microsoft Windows NT vµ cã thÓ thùc hiÖn riªng biÖt trªn Microsoft Windows 95/98: DÞch vô MSSQLServer. DÞch vô SQLServerAgent. DÞch vô MSDTC (Windows NT). Sö dông SQL Server Service Manager: C¸ch khëi ®éng SQL Server - 10 -
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT 1. Tõ nhãm ch−¬ng tr×nh Microsoft SQL Server chän SQL Server Service Manager. 2. Trong hép Service chän MSSQLServer hoÆc MSServerAgent. 3. KÝch vµo nót lÖnh Start. C¸ch ng−ng SQL Server 1. Tõ nhãm ch−¬ng tr×nh Microsoft SQL Server chän SQL Service Manager. 2. Tõ hép Service chän MSSQL Server hoÆc MSServerAgent. 3. NÕu b¹n t¹m dõng SQL Server, kÝch vµo nót Pause ®Ó dõng dÞch vô. 4. KÝch vµo nót Stop ®Ó ngõng ho¹t ®éng. • HoÆc cã thÓ dïng SQL Server Enterprise Manager. - 11 -
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT Ch−¬ng II c¸c ®èi t−îng c¬ së d÷ liÖu I. §èi t−îng c¬ së d÷ liÖu (SLQ-DMO) §èi t−îng c¬ së d÷ liÖu giíi thiÖu thuéc tÝnh ®¬n cña Microsoft SQL Server. Lý do tr×nh bµy c¬ së d÷ liÖu SQL Server, ®èi t−îng c¬ së d÷ liÖu lµ thµnh phÇn chÝnh cña ®èi t−îng c©y SLQ-DMO. §èi t−îng c¬ së d÷ liÖu chøa ®ùng tËp hîp x¸c ®Þnh c¸c b¶ng, c¸c thñ tôc l−u tr÷, lo¹i d÷ liÖu, vµ ng−êi sö dông c¬ së d÷ liÖu. Ph−¬ng thøc cña ®èi t−îng c¬ së d÷ liÖu cho phÐp b¹n thùc hiÖn tr×nh diÔn b¶n chÊt chøc n¨ng duy tr× c¬ së d÷ liÖu, nh− lµ kh«i phôc. Víi ®èi t−îng c¬ së d÷ liÖu, b¹n cã thÓ: 1. T¹o c¬ së d÷ liÖu SQL Server. 2. Thªm c¬ së d÷ liÖu roles, rules, stored procedures, tables, user- defined data types, user, vµ view cho c¬ së d÷ liÖu hiÖn t¹i SQL Server. 3. Gì bá hoÆc xo¸ bá ®èi t−îng c¬ së d÷ liÖu (tables, views, ...) tõ c¬ së d÷ liÖu hiÖn t¹i SQL Server. - 12 -
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT 4. Thay ®æi ®Üa nguån sö dông bëi c¬ së d÷ liÖu l−u tr÷. 5. Kh«i phôc hoÆc l−u tr÷ c¬ së d÷ liÖu hiÖn hµnh. 6. §iÒu khiÓn b¶o mËt c¬ së d÷ liÖu SQL Server bëi thªm users vµ g¸n quyÒn, tõ chèi hoÆc t−íc quyÒn truy cËp tíi c¬ së d÷ liÖu. 7. KiÓm tra tÝnh toµn vÑn c¬ së d÷ liÖu. 8. KiÓm tra h−íng sö dông trong c¬ së d÷ liÖu, riªng biÖt, kiÓm tra tr¹ng th¸i cña kho¸ cung cÊp dùa vµo c¬ së d÷ liÖu nguån. T¹o c¬ së d÷ liÖu SQL Server 1. T¹o ®èi t−îng Database. 2. ThiÕt lËp thuéc tÝnh Name cña ®èi t−îng Database. 3. T¹o ra ®èi t−îng DBFile. 4. ThiÕt lËp thuéc tÝnh Name cña ®èi t−îng DBFile. 5. ThiÕt lËp thuéc tÝnh PhysicalName cña ®èi t−îng DBFile. 6. ThiÕt lËp thuéc tÝnh ®èi t−îng DBFile tuú chän cho c¬ së d÷ liÖu míi nh− kÝch th−íc. 7. Thªm vµo ®èi t−îng DBFile cho ®èi t−îng Database míi, tªn ®èi t−îng FileGroup c¬ b¶n. 8. Thªm vµo ®èi t−îng Database cho tËp hîp Database cña kÕt nèi ®èi t−îng SQL Server. ChØ ®Þnh file ghi 1. T¹o ®èi t−îng LogFile. 2. ThiÕt lËp thuéc tÝnh Name. 3. ThiÕt lËp thuéc tÝnh PhysicalName. 4. ThiÕt lËp thuéc tÝnh LogFile Size. 5. Thªm vµo ®èi t−îng LogFile cho tËp hîp LogFile cña ®èi t−îng Transation, ®èi t−îng Database míi. T¹o gi¶n ®å c¬ së d÷ liÖu Gi¶n ®å c¬ së d÷ liÖu nªn hç trî yªu cÇu giao dÞch lµ v× c¸c yªu cÇu query-driven ®Æc tr−ng cña mét thiÕt kÕ c¬ së d÷ liÖu OLTP. VÝ dô nh− ®−a ra gi¶n ®å c¬ së d÷ liÖu tõ hµng ®−a vµo hÖ thèng: - 13 -
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT X¸c ®Þnh sù kiÖn vµ kÝch th−íc b¶ng. ThiÕt kÕ c¸c b¶ng thùc. ThiÕt kÕ kÝch th−íc b¶ng. I.1 TËp hîp DatabaseRoles TËp hîp DatabaseRoles chøa ®èi t−îng DatabaseRole ®−a ra vai trß ®Æc quyÒn b¶o mËt c¬ së d÷ liÖu trong SQL Server. C¬ së d÷ liÖu Roles trong SQL Server cã thÓ chøa mét hoÆc nhiÒu thµnh viªn (database user). Mét thuéc tÝnh x¸c ®Þnh ng−êi sö dông cã thÓ t¹o ra Databaseroles, thªm vµo hoÆc gì bá chóng tõ Databaseroles, g¸n quyÒn hoÆc phñ nhËn c¬ së d÷ liÖu ®Æc quyÒn tíi roles cho ®Æc quyÒn qu¶n lý mét hoÆc nhiÒu trËt tù logic ng−êi sö dông. - 14 -
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT Víi tËp hîp DatabaseRoles, b¹n cã thÓ: • T¹o ra c¬ së d÷ liÖu roles SQL Server. • Gì bá c¬ së d÷ liÖu roles SQL Server. I.2 TËp hîp c¸c mÆc ®Þnh (Defaults) TËp hîp Defaults chøa ®èi t−îng Default tham chiÕu tíi c¸c mÆc ®Þnh SQL Server. Víi tËp hîp c¸c Defaults, b¹n cã thÓ: T¹o ra c¸c Defaults. Gì bá c¸c Defaults. Qu¸ tr×nh gäi liªn kÕt cho phÐp mét mÆc ®Þnh SQL Server. MÆc ®Þnh cã thÓ giíi h¹n mét hoÆc nhiÒu cét hoÆc lo¹i d÷ liÖu ng−êi sö dông x¸c ®Þnh. Mét giíi h¹n mÆc ®Þnh kh«ng thÓ gì bá. C¸c mÆc ®Þnh (defaults) • Trong SQL Server mçi cét trong b¶n ghi ph¶i chøa ®ùng mét vµi gi¸ trÞ thËm chÝ nÕu gi¸ trÞ ®ã lµ NULL. B¹n x¸c ®Þnh cét nµo cã thÓ chÊp nhËn gi¸ trÞ NULL bëi kiÓu d÷ liÖu, mÆc ®Þnh, hoÆc c¸c rµng buéc. • MÆc ®Þnh chØ ®Þnh gi¸ trÞ mµ SQL Server sÏ chÌn vµo khi ng−êi sö dông kh«ng ®−a vµo gi¸ trÞ (trong c¶ hai cét NULL hoÆc NOT NULL) • Mét c¸ch dÔ dµng nhÊt ®Ó chØ ®Þnh c¸c mÆc ®Þnh lµ x¸c ®Þnh rµng buéc DEFAULT khi b¹n tao nªn b¶ng. • B¹n còng cã thÓ t¹o ra gi¸ trÞ mÆc ®Þnh vµ rµng buéc chóng vµo cét ®Ó ng−êi sö dông x¸c ®Þnh lo¹i d÷ liÖu. I.3 TËp hîp FileGroup TËp hîp FileGroups chøa ®ùng ®èi t−îng FileGroup tham chiÕu FileGroups cña c¬ së d÷ liÖu Microsoft SQL Server. FileGroups Collection (SQL-DMO) Víi tËp hîp c¸c FileGroups, b¹n cã thÓ: T¹o mét SQL Server FileGroups míi. Huû bá SQL Server FileGroups. SQL Server FileGroups cã thÓ ®−îc sö dông kÕt hîp víi file hÖ ®iÒu hµnh sö dông ®Ó duy tr× c¬ së d÷ liÖu. FileGroups cã thÓ ®¬n gi¶n nhiÖm - 15 -
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT vô qu¶n trÞ nh− lµ thao t¸c l−u tr÷ vµ kh«i phôc. Theo mÆc ®Þnh, c¬ së d÷ liÖu SQL Server ®−îc t¹o ra trªn ®óng mét FileGroups gäi lµ PRIMARY. Khi sö dông Item hoÆc Remove, tËp hîp FileGroups hç trî x¸c minh thµnh viªn sö dông mét tªn hoÆc thø tù tham chiÕu có ph¸p. I.4 TËp hîp FullTextCatalogs TËp hîp FullTextCatalogs chøa ®èi t−îng tham chiÕu FullTextCatalogs. Microsoft SQL Server t×m kiÕm liªn tôc d÷ liÖu trong FullTextCatalogs. Víi tËp hîp FullTextCatalogs, b¹n cã thÓ: T¹o mét danh môc chØ sè míi cho Microsoft SQL Server. Xo¸ bá mét danh môc chØ sè cña Microsoft SQL Server. I.5 TËp hîp c¸c quy t¾c (Rules Collection) TËp hîp Rules chøa c¸c ®èi t−îng Rule tham chiÕu Microsoft SQL Server, thùc thi rµng buéc tÝnh toµn vÑn d÷ liÖu nh− lµ c¸c ®èi t−îng c¬ së d÷ liÖu gäi lµ c¸c quy t¾c. Víi c¸c tËp quy t¾c, b¹n cã thÓ: T¹o thùc thi rµng buéc tÝnh toµn vÑn SQL Server nh− lµ c¸c quy t¾c. Xo¸ bá mét quy t¾c x¸c ®Þnh tõ SQL Server. C¸c quy t¾c lµ c¸c ®èi t−îng c¬ së d÷ liÖu mµ nã cã thÓ x¸c ®Þnh c¸c gi¸ trÞ cã thÓ ®−îc chÌn vµo mét cét riªng biÖt. Chó ý r»ng sö dông c¸c rµng buéc lµ ®Ò cËp c¸ch giíi h¹n c¸c cét d÷ liÖu bëi v× nhiÒu rµng buéc cã thÓ x¸c ®Þnh trªn mét cét hoÆc nhiÒu cét. VÝ dô nh− trong mét b¶ng víi cét gäi lµ phone_number, b¹n cã thÓ x¸c ®Þnh quy t¾c mµ x¸c ®Þnh cét chÊp nhËn duy nhÊt 10 con sè ®−a vµo. I.6 TËp hîp c¸c thñ tôc l−u tr÷ (StoredProcedures Collection) TËp hîp StoredProcedures chøa ®èi t−îng StoredProcedure tham chiÕu hÖ thèng vµ ng−êi sö dông x¸c ®Þnh thñ tôc l−u tr÷ cña c¬ së d÷ liÖu Microsoft SQL Server. - 16 -
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT Víi c¸c StoredProcedure, b¹n cã thÓ: T¹o thñ tôc l−u tr÷. Huû thñ tôc l−u tr÷. Sö dông thñ tôc l−u tr÷ (using stored procedures) Thñ tôc l−u tr÷ cã kh¶ n¨ng më réng, hiÖu qu¶ vµ cã tÝnh mÒm dÎo cña SQL Server, vµ ®ét ngét c¶i tiÕn thùc hiÖn c©u lÖnh SQL vµ file bat. Thñ tôc l−u tr÷ cã thÓ: NhËn tham sè. Gäi c¸c thñ tôc kh¸c. Trë l¹i gi¸ trÞ tr¹ng th¸i ®Ó gäi thñ tôc hoÆc file bat tíi chØ ®Þnh thµnh c«ng hoÆc thÊt b¹i. Trë l¹i gi¸ trÞ cña tham sè gäi thñ tôc hoÆc file bat. Thñ tôc l−u tr÷ cã thÓ dïng kü thuËt b¶o mËt, bëi v× ng−êi sö dông cã thÓ ®−îc g¸n quyÒn ®Ó thùc hiÖn thñ tôc l−u tr÷ thËm chÝ hä kh«ng thÓ thùc hiÖn trªn b¶ng hoÆc khung nh×n tham chiÕu tíi nã. T¹o ra thñ tôc l−u tr÷ B¹n cã thÓ t¹o ra thñ tôc l−u tr÷ sö dông c©u lÖnh CREATE PROCEDURE Transact-SQL. Tr−íc khi t¹o thñ tôc l−u tr÷, cÇn l−u ý ®Õn: C©u lÖnh CREATE PROCEDURE kh«ng thÓ kÕt hîp víi c©u lÖnh Transact-SQL kh¸c trong file bat ®¬n. Cho phÐp thùc hiÖn t¹o c©u lÖnh CREATE PROCEDURE mÆc ®Þnh tíi c¬ së d÷ liÖu cña ng−êi t¹o ra nã vµ cã thÓ chuyÓn giao nã tíi ng−êi sö dông kh¸c. Thñ tôc l−u tr÷ lµ c¬ së d÷ liÖu ®èi t−îng vµ mçi tªn ph¶i tu©n theo quy t¾c chØ ®Þnh. B¹n cã thÓ t¹o ra thñ tôc l−u tr÷ duy nhÊt trong c¬ së d÷ liÖu hiÖn hµnh. Khi b¹n t¹o ra thñ tôc l−u tr÷, b¹n nªn chØ ®Þnh: BÊt kú tham sè ®Çu vµo vµ tham sè ®Çu ra theo h−íng gäi thñ tôc hoÆc tÖp bat. C¸c c©u lÖnh ch−¬ng tr×nh thùc hiÖn thao t¸c trong c¬ së d÷ liÖu, bao gåm h−íng tíi thñ tôc kh¸c. - 17 -
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT Tr¹ng th¸i gi¸ trÞ trë l¹i theo h−íng thñ tôc hoÆc tÖp bat cho biÕt thµnh c«ng hoÆc thÊt b¹i. T¹o ra thñ tôc l−u tr÷: Tõ menu trong SQL Server Enterprise Manager, chän c¬ së d÷ liÖu muèn t¹o thñ tôc l−u tr÷, råi kÝch chuét ph¶i vµo Stored procedure chän New stored procedure... Sö dông c©u lÖnh CREATE PROCEDURE. Quy t¾c ch−¬ng tr×nh thñ tôc l−u tr÷ gåm cã: X¸c ®Þnh c©u lÖnh CREATE PROCEDURE cã thÓ gåm bÊt kú sè vµ kiÓu c©u lÖnh SQL lo¹i trõ c©u lÖnh CREATE, mµ kh«ng thÓ sö dông bÊt cø chç nµo trong thñ tôc l−u tr÷: CREATE DEFAULT CREATE TRIGGER CREATE PROCEDURE CREATE VIEW CREATE RULE C¸c ®èi t−îng c¬ së d÷ liÖu kh¸c cã thÓ t¹o trong thñ tôc l−u tr÷. B¹n cã thÓ tham chiÕu ®èi t−îng t¹o ra trong mét thñ tôc l−u tr÷ chØ cÇn ®−îc t¹o ra tr−íc khi nã ®−îc tham chiÕu. B¹n cã thÓ tham chiÕu c¸c b¶ng t¹m trong thñ tôc l−u tr÷. Sè l−îng lín nhÊt cña tham sè trong thñ tôc lµ 1024. Sè l−îng lín nhÊt cña biÕn côc bé trong thñ tôc l−u tr÷ lµ giíi h¹n bëi bé nhí cã s½n. Tuú thuéc vµo bé nhí, kÝch th−íc cùc ®¹i cña thñ tôc l−u tr÷ lµ 128 MB. X¸c ®Þnh tªn bªn trong thñ tôc l−u tr÷ • Bªn trong thñ tôc l−u tr÷, tªn ®èi t−îng sö dông víi c¸c c©u lÖnh (vÝ dô nh− SELECT hoÆc INSERT) mµ kh«ng x¸c ®Þnh ng−êi sö dông mÆc ®Þnh cho thñ tôc l−u tr÷ cña chÝnh m×nh. NÕu ng−êi sö dông mµ t¹o ra thñ tôc l−u tr÷ kh«ng x¸c ®Þnh tªn cña b¶ng tham chiÕu trong c©u lÖnh SELECT, INSERT, UPDATE, hoÆc DELETE trong thñ tôc l−u tr÷, truy cËp b¶ng nµy th«ng qua thñ tôc l−u tr÷ lµ giíi h¹n bëi mÆc ®Þnh ®Ó t¹o ra thñ tôc. • Tªn ®èi t−îng sö dông víi c©u lÖnh ALTER TABLE, CREATE TABLE, DROP TABLE, TRUNCATE TABLE, CREATE INDEX, DROP INDEX, UPDATE STATISTICS, vµ DBCC ph¶i ®ñ kh¶ - 18 -
- LuËn v¨n tèt nghiÖp Vò Hïng C−êng B2 - CNTT n¨ng cïng víi sù hiÖn diÖn tªn cña chÝnh ®èi t−îng nÕu ng−êi sö dông kh¸c lµ sö dông thñ tôc l−u tr÷. §æi tªn thñ tôc l−u tr÷ 1. Më réng mét sever group, råi më réng server. 2. Më réng Database, më réng c¬ së d÷ liÖu mµ thñ tôc thuéc vÒ nã råi kÝch Stores procedure. 3. Trong detail pane, kÝch ph¶i stored procedure, chän rename. 4. Gâ tªn míi cña thñ tôc. Thùc hiÖn thñ tôc l−u tr÷ hÖ thèng ps_rename. Xo¸ mét thñ tôc l−u tr÷. 1. Më réng mét sever group, råi më réng server. 2. Më réng Database, më réng c¬ së d÷ liÖu mµ thñ tôc thuéc vÒ nã råi kÝch Stores procedure. 3. Trong detail pane, kÝch ph¶i stored procedure, chän delete. 4. §Ó xem c¸ch xo¸ bá thñ tôc l−u tr÷ sÏ ¶nh h−ëng nh− thÕ nµo tíi c¬ së d÷ liÖu, nhÊp show dependencies. 5. NhÊp Drop all. Sö dông c©u lÖnh DROP PROCEDURE. I.7 TËp hîp kiÓu d÷ liÖu hÖ thèng (SystemDatatypes Collection) TËp hîp SystemDatatypes chøa ®èi t−îng SystemDatatype liÖt kª kiÓu d÷ liÖu c¬ b¶n cña cµi ®Æt Microsoft SQL Server. SQL Server x¸c ®Þnh sè l−îng cè ®Þnh kiÓu d÷ liÖu c¬ b¶n. Bëi v× sè l−îng lµ cè ®Þnh, tËp hîp SystemDatatypes, miªu t¶ kiÓu d÷ liÖu nµy, cè ®Þnh c¸c thµnh viªn vµ kh«ng hç trî ph−¬ng thøc Add hoÆc Remove. I.8 TËp hîp c¸c b¶ng (Tables Collection) T©p hîp c¸c b¶ng chøa ®èi t−îng b¶ng tham chiÕu hÖ thèng vµ x¸c ®Þnh c¸c b¶ng cña ng−êi sö dông cña c¬ së d÷ liÖu Microsoft SQL Server. - 19 -
CÓ THỂ BẠN MUỐN DOWNLOAD
-
Luận văn tốt nghiệp "Tìm hiểu công nghệ XML và xây dựng hệ thống quản lý dịch vụ khách hàng (esupport)"
126 p |
597 |
222
-
Đồ án tốt nghiệp - tìm hiểu về virut máy tính và cách phòng chống
248 p |
467 |
199
-
Luận văn tốt nghiệp: Tìm hiểu SQL Server và sử dụng nó để giải quyết bài toán quản lý dân cư
84 p |
278 |
166
-
Luận văn tốt nghiệp môn Mạng máy tính: Nghiên cứu một số vấn đề về bảo mật ứng dụng Web trên Internet
169 p |
304 |
162
-
Luận văn tốt nghiệp: Một số biện pháp tăng cường sử dụng công nghệ thông tin trong việc quản lý hành chính nhà nước
73 p |
281 |
134
-
LUẬN VĂN TỐT NGHIỆP-ĐỀ TÀI: “ Thiết kế mạch đồng hồ hiển thị ngày, tháng, năm, giờ, phút, giây dùng IC số”
65 p |
216 |
107
-
Luận văn tốt nghiệp : Tìm hiểu Simulink trong matlab
50 p |
177 |
88
-
Luận văn tốt nghiệp: Nhận dạng người dựa vào thông tin khuôn mặt xuất hiện trên ảnh
180 p |
200 |
86
-
ĐỒ ÁN TỐT NGHIỆP - TÌM HIỂU VỀ TẤN CÔNG TRÊN MẠNG DÙNG KỸ THUẬT DOS DDOS
15 p |
216 |
82
-
Báo cáo Luận văn Tốt nghiệp: Tìm hiểu công nghệ nhận dạng hình ảnh
30 p |
130 |
61
-
Luận văn Tốt nghiệp cử nhân CNTT: Nhận dạng ký tự ảnh
67 p |
88 |
41
-
Luận văn tốt nghiệp: Máy nghe nhạc sử dụng chip Arm Cortex M3 32 bit
115 p |
71 |
38
-
Luận văn tốt nghiệp: Tìm hiểu SQL server
84 p |
58 |
25
-
Luận văn Tốt nghiệp: Nhận dạng ngôn ngữ
59 p |
44 |
17
-
Đồ án tốt nghiệp: Tìm hiểu về Vmware esx server
84 p |
62 |
16
-
Luận văn tốt nghiệp: Nghiên cứu và xây dựng hệ thống phần mềm hỗ trợ việc dạy học trực tuyến trên mạng internet/intranet
0 p |
44 |
16
-
Luận văn tốt nghiệp: Cổng báo cáo tổng hợp trực tuyến phục vụ HTTT chỉ đạo ngành Y tế cộng đồng
0 p |
63 |
13

WARC-Type: response

Content-Type: application/http; msgtype=response

WARC-Identified-Payload-Type: application/xhtml+xml

Connection: close

Pragma: no-cache

Cache-Control: no-store, no-cache, must-revalidate, post-check=0, pre-check=0

Set-Cookie: TLDEVNamespace=iconguj44dk2u934j97d3lluv3; path=/; domain=.tailieu.vn; HttpOnly

Vary: Accept-Encoding

Content-Type: text/html; charset=UTF-8


markdown:
# Nghị định số 53-HĐBT
Chia sẻ: Son Nguyen | Ngày: | Loại File: PDF | Số trang:5
lượt xem 7
download
![](http://image.tlvnimg.com/document/thumbnail/2009/20091119/lawvhxh17/80x100/5713.jpg)
##
Nghị định số 53-HĐBT
[Vui lòng tải xuống để xem tài liệu đầy đủ](javascript:void(0);)
Download
![](http://static.tlvnimg.com/b2013az/templates/version1/default/images/down16x21.png)
Nghị định số 53-HĐBT về Điều lệ khen thưởng thành tích thực hiện kế hoạch Nhà nước và các nhiệm vụ công tác khác do Hội đồng Bộ trưởng ban hành
Bình luận(0)
[Đăng nhập để gửi bình luận!](javascript:void(0);)
##
Nội dung Text: Nghị định số 53-HĐBT
- H I NG B TRƯ NG C NG HOÀ XÃ H I CH NGHĨA VI T NAM ******** c l p - T do - H nh phúc ******** S : 53-H BT Hà N i, ngày 25 tháng 2 năm 1985 NGHN NNH C AH I NG B TRƯ NG S 53-H BT NGÀY 25-2-1985 BAN HÀNH I U L KHEN THƯ NG THÀNH TÍCH TH C HI N K HO CH NHÀ NƯ C VÀ CÁC NHI M V CÔNG TÁC KHÁC H I NG B TRƯ NG Căn c Lu t t ch c H i ng b trư ng ngày 4-7-1981; ưa công tác khen thư ng các ngành, các c p vào n n p; xét ngh c a Vi n trư ng Vi n Huân chương, NGHN NNH : i u 1.- Ban hành kèm theo ngh nh này b n i u l khen thư ng thành tích th c hi n k ho ch Nhà nư c và các nhi m v công tác khác. i u 2.- Các B trư ng; Ch nhi m U ban Nhà nư c, th trư ng cơ quan khác thu c H i ng B trư ng, Ch t ch U ban nhân dân các tinh, thành ph , c khu tr c thu c Trung ương ch u trách nhi m thi hành Ngh nh này. i u 3.- B n i u l này có hi u l c t ngày 1 tháng 3 năm 1985 và thay cho các Thông tư s 6/TTg ngày 18-1-1963, s 11/TTg ngày 30-1- 1964, s 38/TTg ngày 21- 2-1967 v khen thư ng thành tích th c hi n k ho ch Nhà nư c và các nhi m v công tác khác. T H u ( ã ký) I U L KHEN THƯ NG THÀNH TÍCH TH C HI N K HO CH NHÀ NƯ C VÀ CÁC NHI M V CÔNG TÁC KHÁC (Ban hành kèm theo Ngh nh s 53-H BT ngày 25-2-1985). bi u dương nh ng thành tích c a các t p th và cá nhân ã có nh ng óng góp x ng áng vào s nghi p xây d ng ch nghĩa xã h i và b o v T qu c xã h i ch nghĩa, ng viên nhân dân và cán b hăng hái thi ua hoàn thành t t k ho ch Nhà
- nư c và m i nhi m v công tác khác, góp ph n thúc Ny s n xu t phát tri n m nh m , thi t th c c i thi n i s ng v t ch t và văn hoá c a nhân dân, em l i ph n vinh cho t nư c. vi c khen thư ng ti n hành ư c ch t ch , b o m chính xác, k p th i và có tác d ng ng viên, giáo d c, nêu gương. Nay quy nh ch khen thư ng thành tích th c hi n k ho ch Nhà nư c và các nhi m v công tác khác. Chương 1: I TƯ NG VÀ TIÊU CHU N KHEN THƯ NG i u 1.- i tư ng ư c xét khen thư ng: Các i tư ng sau ây có thành tích u ư c xét khen thư ng: 1. Các ngành, a phương, cơ quan Nhà nư c, các t ch c kinh t qu c doanh và t p th . 2. Các cán b , công nhân, viên ch c Nhà nư c; các thành viên c a t ch c t p th và cá nhân công dân. 3. Chi n sĩ các l c lư ng vũ trang nhân dân làm nhi m v xây d ng kinh t . i u 2.- Tiêu chuNn khen thư ng: Tiêu chuNn xét khen thư ng ơn v ho c cá nhân g m có: A. I V I ƠN VN 1- ư c cơ quan có thN m quy n công nh n hoàn thành và hoàn hành vư t m c t t c các ch tiêu k ho ch Nhà nư c, các nhi m v công tác khác; ho c hoàn thành và hoàn thành vư t m c các ch tiêu ch y u, có ý nghĩa quan tr ng i v i n n kinh t qu c dân. Có phong trào thi ua xã h i ch nghĩa liên t c và u kh p; kh c ph c ư c nhi u khó khăn, phát huy sáng ki n, th c hi n ti t ki m, t năng xu t, ch t lư ng và hi u qu cao. 2. Th c hi n t t nghĩa v i v i Nhà nư c (k c nghĩa v quân s ); ch p hành nghiêm ch nh ư ng l i, chính sách c a ng, pháp lu t Nhà nư c và nh ng quy nh c a ngành ( c bi t là ch trách nhi m, ch k lu t, ch d b o v c a công và ch ph c v nhân dân); có bi n pháp tích c c ngăn ch n, xoá b các hi n tư ng tiêu c c trong qu n lý kinh t , qu n lý xã h i. 3. T ch c t t i s ng v t ch t và văn hoá trong ơn v .
- 4. B o v s n xu t, gi gìn bí m t, b o m tr t t và an toàn xã h i, s n sàng chi n u t t. B. I V I CÁ NHÂN 1. Hoàn thành có ch t lư ng và vư t m c các ch tiêu k ho ch ho c nhi m v công tác ư c giao; có sáng ki n c i ti n qu n lý, c i ti n k thu t, c i ti n t ch c và nghi p v công tác, em l i nhi u l i ích cho Nhà nư c, cho t p th . 2. Nghiêm ch nh ch p hành ư ng l i chính sách c a ng, pháp lu t Nhà nư c và k lu t lao ng; tích c c u tranh ch ng tiêu c c. 3. Có ý th c ti t ki m và b o v c a công; luôn luôn h c t p nâng cao trình chuyên môn, nghi p v . 4. Tích c c b o v ơn v , gi gìn bí m t, s n sàng chi n u b o v T qu c. Chương 2: TH M QUY N VÀ TH T C XÉT DUY T VÀ NGHN CÁC M C KHEN THƯ NG i u 3.- ThN m quy n xét duy t và ngh các m c khen thư ng. 1. Th trư ng các B , U ban Nhà nư c, các cơ quan thu c h i ng B trư ng, các oàn th trung ương và Ch t ch U ban Nhân dân các t nh, thành ph , c khu tr c thu c Trung ương (sau ây g i t t là B , U ban nhân dân t nh) xét và quy t nh t ng b ng khen c a B , U ban Nhân dân t nh cho: - Các ơn v tiên ti n; các t p th và cá nhân có thành tích xu t s c trong các ơn v tr c thu c; - Các t p th và cá nhân ư c công nh n danh hi u t , i lao ng xã h i ch nghĩa, chi n sĩ thi ua. 2. H i ng B trư ng xét và Ch t ch H i ng B Trư ng t ng b ng khen cho: - Các t p th và cá nhân có thành tích xu t s c tiêu bi u c a B , c a t nh; - Các t p th và cá nhân ư c công nh n danh hi u t , i lao ng xã h i ch nghĩa, chi n sĩ thi ua nhi u năm li n, tiêu bi u cho phong trào thi ua trong các ơn v tr c thu c B ho c t nh. 3. H i ng B trư ng ngh H i ng Nhà nư c xét và quy t nh t ng huân chương Lao ng các h ng cho: - Các t p th và cá nhân có thành tích xu t s c tiêu bi u trong toàn qu c; - Các t p th và cá nhân có thành tích xu t s c c a B , c a t nh trong nhi u năm li n;
- - Các t p th và cá nhân ư c công nh n danh hi u thi ua nhi u năm li n, tiêu bi u cho phong trào thi ua c a B , c a t nh. i u 4.- Th t c xét duy t và ngh khen thư ng. 1. Xét khen thư ng thư ng kỳ hàng năm. a) ơn v cơ s khi xét ngh khen thư ng, th trư ng ph i l y ý ki n c a các oàn th qu n chúng. b) B , U ban Nhân dân t nh ch xét duy t và ngh khen thư ng sau khi ã có k t lu n chính th c c a h i ng xét duy t k t qu th c hi n k ho ch Nhà nư c và sau khi ã t ng k t công tác và bình b u thi ua; khi xét duy t và ngh ph i ti n hành trong t p th lãnh o B , U ban Nhân dân t nh và ph i ki m tra, xác minh k các thành tích ngh H i ng B trư ng xét khen thư ng. Trư ng h p B ngh H i ng B trư ng xét khen thư ng các ơn v tr c thu c B óng t nh; khen thư ng nhân dân và cán b ho c t ch c ngành, oàn th c a t nh có thành tích v lĩnh v c công tác do B qu n lý, ph i có s nh t trí c a U ban Nhân dân t nh. Trư ng h p U ban Nhân dân t nh ngh H i ng B trư ng xét khen thư ng các cơ s , các ngành và các oàn th c a t nh có thành tích v lĩnh v c công tác do B qu n lý, ph i có s nh t trí c a B ch qu n. 2. Vi c xét khen thư ng t xu t cho các t p th và cá nhân có thành tích trong quá trình th c hi n k ho ch Nhà nư c, nhi m v công tác thì ch y u do các B , U ban Nhân dân t nh xét t ng b ng khen ng viên k p th i; i v i các t p th và cá nhân có thành tích th t xu t s c thì m i ngh H i ng B trư ng xét khen thư ng. i u 5- N i dung h sơ ngh khen thư ng. 1. H sơ ngh H i ng B trư ng xét khen thư ng g m có: a) Văn b n ngh xét khen thư ng c a th trư ng B ho c Ch t ch U ban Nhân dân t nh. b) B n thành tích c a ơn v ho c cá nhân ư c ngh khen thư ng có ý ki n xác nh n c a th trư ng c p trên tr c ti p. c) ý ki n c a B ho c U ban Nhân dân t nh v các trư ng h p khen thư ng nêu i u 4. 2. H sơ ngh khen thư ng t p th ho c cá nhân có phát minh, sáng ch , sáng ki n ng d ng khoa h c và k thu t, ho c sáng t o v các lĩnh v c khác ph i ính kèm theo văn b n ch ng nh n c a U ban Khoa h c và k thu t Nhà nư c ho c c a các cơ quan có thN m quy n xác nh n thành tích.
- 3. Các d ngh khen thư ng t ng k t thành tích th c hi n k ho ch Nhà nư c c a năm trư c, thành tích th c hi n k ho ch nhà nư c nhi u năm, ph i g i lên H i ng B trư ng (Vi n Huân chương) ch m nh t là ngày 15 tháng 3 hàng năm. Chương 3: CÔNG B KHEN THƯ NG THU H I HÌNH TH C KHEN THƯ NG i u 6.- Công b khen thư ng. 1. Hàng năm, Nhà nư c công b khen thư ng t ng k t thành tích th c hi n k ho ch Nhà nư c và các nhi m v công tác khác c a năm trư c vào d p 1-5 năm sau. Công b khen thư ng t ng k t thành tích th c hi n k ho ch Nhà nư c và các nhi m v khác liên t c nhi u năm vào d p l Qu c khánh 2-9. 2. Trư ng h p xét khen t xu t s công b ngay sau khi ư c c p có thN m quy n quy t nh. i u 7.- Thu h i hình th c khen thư ng. Các t p th và cá nhân do khai thành tích không úng mà ư c khen thư ng ho c sau khi ư c khen thư ng ã ph m sai l m nghiêm tr ng, không còn x ng áng n a s b thu h i hình th c khen thư ng. Cơ quan quy t nh khen thư ng xét và quy t nh vi c thu h i. Chương 4: I U KHO N THI HÀNH i u 8.- Các th trư ng ngành Trung ương và U ban Nhân dân t nh, thành ph và c khu tr c thu c trung ương c n t ch c ph bi n B n i u l này n t n cơ s cho nhân dân và cán b công nhân, viên ch c hi u rõ và ch p hành nghiêm ch nh. Vi n huân chương giúp Ch t ch H i ng B trư ng ki m tra, ôn c vi c xét duy t và ngh khen thư ng các ngành, các c p theo úng quy nh c a B n i u l này.
CÓ THỂ BẠN MUỐN DOWNLOAD
-
Nghị định số 70/2008/NĐ-CP
8 p |
416 |
127
-
Nghị định số 13/2008/NĐ-CP
12 p |
112 |
21
-
Nghị định số 68/2008/NĐ-CP
13 p |
148 |
17
-
Nghị định số 69/2008/NĐ-CP
13 p |
122 |
16
-
Nghị định số 08/2009/NĐ-CP
12 p |
100 |
12
-
Nghị định số 64/2008/NĐ-CP
14 p |
113 |
10
-
Nghị định số 117/2008/NĐ-CP
21 p |
135 |
9
-
Nghị định số 04/2008/NĐ-CP
6 p |
131 |
9
-
Nghị định số 38/2009/NĐ-CP
11 p |
141 |
7
-
Nghị định số 10/2008/NĐ-CP
2 p |
78 |
6
-
Nghị định số 11/2008/NĐ-CP
5 p |
61 |
6
-
Nghị định số 89/2008/NĐ-CP
4 p |
124 |
5
-
Nghị định số 78/2008/NĐ-CP
11 p |
79 |
5
-
Nghị định số 149/2007/NĐ-CP
14 p |
46 |
5
-
Nghị định số 76/2008/NĐ-CP
5 p |
82 |
3
-
Nghị định số 07/2008/NĐ-CP
9 p |
47 |
3
-
Nghị định số 12/2008/NĐ-CP
7 p |
45 |
3
-
Nghị định số 11/2009/NĐ-CP
8 p |
53 |
3

Set-Cookie: TLDEVNamespace=1nu45avrks76pnhj2lk29ruhf6; path=/; domain=.tailieu.vn; HttpOnly


markdown:
# Quyết định số 880/QĐ-UB
Chia sẻ: Sang Nguyen | Ngày: | Loại File: PDF | Số trang:7
lượt xem 2
download
##
Quyết định số 880/QĐ-UB
[Vui lòng tải xuống để xem tài liệu đầy đủ](javascript:void(0);)
Download
![](http://static1.tailieu.vn/b2013az/templates/version1/default/images/down16x21.png)
Quyết định số 880/QĐ-UB về việc ban hành quy định về kiểm tra xử lý việc sản xuất, buôn bán hàng giả tại thành phố Hồ Chí Minh do Ủy ban nhân dân thành phố Hồ Chí Minh ban hành
Bình luận(0)
[Đăng nhập để gửi bình luận!](javascript:void(0);)
##
Nội dung Text: Quyết định số 880/QĐ-UB
- ỦY BAN NHÂN DÂN CỘNG HÒA XÃ HỘI CHỦ NGHĨA VIỆT NAM THÀNH PHỐ HỒ CHÍ MINH Độc lập - Tự do - Hạnh phúc ------- --------- Số: 880/QĐ-UB Tp. Hồ Chí Minh, ngày 5 tháng 6 năm 1992 QUYẾT ĐỊNH VỀ VIỆC BAN HÀNH QUY ĐỊNH VỀ KIỂM TRA XỬ LÝ VIỆC SẢN XUẤT, BUÔN BÁN HÀNG GIẢ TẠI THÀNH PHỐ HỒ CHÍ MINH ỦY BAN NHÂN DÂN THÀNH PHỐ HỒ CHÍ MINH Căn cứ Luật Tổ chức Hội đồng nhân dân và Ủy ban nhân dân ngày 30 tháng 6 năm 1989; Căn cứ Pháp lệnh xử phạt vi phạm hành chánh ngày 30 tháng 11 năm 1989; Căn cứ Nghị định 140/HĐBT ngày 25 tháng 4 năm 1991 của Hội dồng Bộ trưởng quy định về kiểm tra, xử lý việc sản xuất buôn bán hàng giả; Xét đề nghị của Chủ nhiệm Ủy ban Khoa học kỹ thuật thành phố và Giám đốc Sở Tư pháp; QUYẾT ĐỊNH: Điều 1. Nay ban hành qui định về kiểm tra, xử lý việc sản xuất, buôn bán hàng giả tại thành phố Hồ Chí Minh. Điều 2. Quyết định này có hiệu lực thi hành từ ngày ban hành. Điều 3. Các đồng chí Chánh Văn phòng Ủy ban nhân dân thành phố, Giám đốc và Thủ trưởng các sở, ban, ngành thành phố, Chủ tịch Ủy ban nhân dân các quận, huyên chịu trách nhiệm thi hành quyết định này.- TM. ỦY BAN NHÂN DÂN KT. CHỦ TỊCH PHÓ CHỦ TỊCH Vương Hữu Nhơn
- QUY ĐỊNH VỀ KIỂM TRA, XỬ LÝ VIỆC SẢN XUẤT, BUÔN BÁN HÀNG GIẢ TẠI THÀNH PHỐ HỒ CHÍ MINH (Ban hành kèm theo Quyết định số 880/QĐ-UB ngày 5 – 6- 1992 của Ủy ban nhân dân thành phố ) Chương I. NHỮNG QUY ĐỊNH CHUNG Điều 1. Mọi tổ chức cá nhân sản xuất kinh doanh thuộc các thành phần kinh tế trên địa bàn thành phố phải chịu trách nhiệm về chất lượng sản phẩm, hàng hoá của mình, phải tuân thủ việc kiểm tra chất lượng của cơ quan quản lý Nhà nước có thẩm quyền. Điều 2. 1/ Nghiêm cấm mọi tổ chức, cá nhân sản xuất kinh doanh, tàng trữ hàng giả, nhãn hiệu, bao bì và các tài liệu hướng dẫn liên quan đến hàng giả. 2/Cá nhân nào không chấp hành, xúi giục kích động người khác không chấp hành các yêu cầu của lực lượng kiểm tra xử lý hàng giả sẽ bị xử lý theo pháp luật hiện hành. Mọi vi phạm tuỳ theo tính chất và mức độ sẽ bị xử lý hành chánh theo quy định này hoặc bị truy tố theo Bộ luật hình sự. Điều 3. Hàng giả là những sản phẩm hàng hoá được sản xuất trái pháp luật có hình dáng giống như những sản phẩm, hàng hoá được cho phép sản xuất, nhập khẩu và tiêu thụ trên thị trường, hoặc những sản phẩm hàng hoá không có giá trị sử dụng với nguồn gốc bản chất tự nhiên, tên gọi và công dụng của nó. Điều 4. Sản phẩm hàng hoá có một trong những dấu hiệu dưới đây được coi là hàng giả. 1/ Sản phẩm, hàng hoá mang nhãn hiệu hàng hoá giống hệt hoặc tương tư có khả năng làm cho người tiêu dùng nhầm lẫn với nhãn hiệu hàng hoá của cơ sở sản xuất kinh doanh khác đã đăng ký với cơ quan bảo hộ quyền sở hữu công nghiệp hoặc đã được bảo hộ theo điều ước quốctế mà Việt Nam tham gia. 2/ Sản phẩm hàng hoá mang nhãn sản phẩm không đúng với mẫu đã đăng ký với cơ quan quản lý Nhà nước về tiêu chuẩn đo lường chất lượng hoặc mang nhãn sản phẩm của cơ sở khác đã đăng ký mà không được chủ nhãn đồng ý. 3/ Sản phẩm, hàng hoá có nội dung, chất lượng, xuất xứ không đúng như đã nêu trên nhãn sản phẩm hoặc như đã quảng cáo.
- 4/ Sản phẩm, hàng hoá mang các dấu hiệu kiểm định, giám định Nhà nước, dấu hiệu phù hợp tiêu chuẩn Việt Nam hoặc các dấu hiệu khen thưởng khác khi chưa được cơ quan có thẩm quyền cấp, hoặc đã bị thu hồi, hoặc đã hết thời hạn. 5/ Sản phẩm, hànhg hoá cũ được tân trang, phục hồi và giả mạo các dấu hiệu niêm bảo hành, xuất xưởng làm cho khách hàng nhầm lẫn giữa hàng mới và hàng cũ. 6/ Sản phẩm hàng hoá bị biến tạo, pha trộn làm giảm chất lượng. 7/ Sản phẩm hàng hoá có chất lượng thấp hơn mức chất lượng tối thiểu cho phép. 8/ Sản phẩm, hàng hóa có giá trị sử dụng không đúng với nguồn gốc, bản chất tự nhiên, tên gọi và công dụng của nó. Điều 5. 1/ Lượng hàng vi phạm bao gồm những hàng hóa đã tiêu thụ và lượng hàng bị phát hiện. 2/ Giá trị lượng hàng vi phạm để làm căn cứ xử lý tính theo giá bán lẻ của hàng thật cùng loại vào thời điểm bị phát hiện. Điều 6. Hành vi in ấn, làm dịch vụ, buôn bán nhãn hiệu, bao bì trái với quy định trong Thông tư Liên bộ số 1191/TTLB ngày 29-6-1991 về quản lý nhãn và quảng cá sản phẩm, hàng hoá sẽ bị xử lý theo quy định trong văn bản này. Điều 7. Hành vi làm và buôn bán hàng giả đồng thời xâm phạm quyền sở hữu công nghiệp thì ngoài việc bị xử lý theo qui định này còn bị xử lý theo pháp luật về bảo vệ quyền sở hữu công nghiệp. Điều 8. Tổ chức cá nhân làm và buôn bán hàng giả là thuốc chữa bệnh, thực phẩm chế biến, thuốc trừ sâu, xi măng, phân bón, đồ điện và các loại hàng giả khác gây nguy hiểm nghiêm trọng đến sức khoẻ tính mạng người tiêu dùng và an toàn xã hội, hoặc đã hai lần bị xử lý hành chánh về hành vi làm và buôn bán hàng giả thì bị truy tố theo Bộ luật hình sự. Điều 9. Ngoài việc bị xử lý theo bản quy định này, người hoặc tổ chức làm hàng giả còn phải bồi thường thiệt hại do hành vi làm và buôn bán hàng giả gây ra. Điều 10. Ủy quyền cho Chủ nhiệm Ủy ban Khoa học kỹ thuật thành phố tham khảo ý kiến qua Ban Vật giá thành phố ấn định lại mức tiền phạt khi giá trị của mức tiền phạt nói trên chỉ còn bằng 70% so với thời điểm ban hành quy định này. Chương II. CÁC HÌNH THỨC XỬ LÝ
- Điều 11. Cảnh cáo đối với hành vi làm hoặc buôn bán hàng giả, buôn bán nhãn hiệu, bao bì mà trị giá hàng không quá hai chục ngàn (20.000 đồng) Điều 12. 1/ Phạt tiền từ 1 đến 3 lần số lợi bất chính hoặc từ 10% đến 50% trị giá hàng nếu hàng còn giá trị sử dụng, nhưng không thấp hơn 1.000.000 đồng. - Phạt tiền từ một đến ba lần trị giá hàng nếu hàng không có giá trị sử dụng (bao gồm hàng hoá không đúng với nguồn gốc, bản chất tự nhiên, tên gọi, công dụng của nó hoặc hàng có chất lượng dưới mức tối thiểu cho phép) nhưng không thấp hơn 2.000.000 đồng. 2/ Phạt tiền gấp ba lần trị giá số nhãn hiệu, bao bì, in ấn, buôn bán trái phép, phạt tiền gấp ba lần số lợi bất chính đối với dịch vụ in ấn nhãn hiệu, bao bì liên quan đến hàng giả, nhưng không thấp hơn 200.000 đồng. Điều 13. Ngoài việc xử lý theo điều 11 hoặc điều 12 nêu trên, tổ chức hoặc cá nhân vi phạm còn bị xử lý bằng các hình thức sau: 1/ Tịch thu đối với: + Hàng giả không có giá trị sử dụng + Các loại nhãn hiệu, bao bì in ấn và buôn bán trái phép. 2/ Buộc tiêu thụ ở những địa điểm do cơ quan quản lý chỉ định đối với hàng giả còn giá trị sử dụng. Trường hợp này người chủ phải huỷ bỏ nhãn hiệu, dấu hiệu giả mạo, thay bằng nhãn sản phẩm ghi đúng mục đích sử dụng xuất xứ, chất lượng của hàng hoá đó. 3/ Tịch thu các loại máy móc, dụng cụ dùng để sản xuất hàng giả hoặc in ấn trái phép và tước giấy phép kinh doanh của cơ sở sản xuất kinh doanh đã bị xử lý một lần về hành vi làm và buôn bán hàng giả mà tái phạm. Chương III. TRÁCH NHIỆM, QUYỀN HẠN CỦA CÁC CƠ QUAN TRONG VIỆC KIỂM TRA, XỬ LÝ HÀNG GIẢ Điều 14. Thẩm quyền xử lý. 1/ Chiến sĩ, cảnh sát, nhân viên hải quan, nhân viên quản lý thị trường đang làm nhiệm vụ có quyền phạt cảnh cáo. 2/ Thanh tra viên văn hoá, thanh tra viên Nhà nước về chất lương hàng hoá đang hti hành công vụ có quyền phạt cảnh cáo, phạt tiền đến 200.000 đồng.
- 3/ Trưởng hải quan cửa khẩu có quyền phạt tiền đến 1.000.000 đồng, tịch thu các loại nhãn hiệu, bao bì xuất nhập khẩu trái phép. 4/ Chi cục Trưởng Chi cục tiêu chuẩn đo lường chất lượng thành phố, Trưởng ban chỉ đạo quản lý thị trường thành phố, Giám đốc Công an thành phố có quyền phạt tiền đến 2.000.000 đồng và áp dụng các hình thức xử phạt khác nêu trong bản qui định này. 5/ Giám đốc Hải quan thành phố có quyền phạt tiền trên 1.000.000 đồng và tịch thu hàng giá xuất nhập khẩu. 6/ Chủ tịch Ủy ban nhân dân quận, huyện có quyền phạt tiền đến 2.000.000 đồng và áp dụng các hình thức xử phạt khác nêu trong bản qui định này. 7/ Chủ tịch Ủy ban nhân dân thành phố có quyền phạt tiền trên 5.000.000 đồng và áp dụng các hình thức xử phạt khác nêu trong bản qui định này. Điều 15. Những vụ việc do đội kiểm tra liên ngành phát hiện sẽ do Chủ tịch Ủy ban nhân dân quận, huyện hoặc thành phố xử lý trên cơ sở đề nghị của Đội trưởng đội kiểm tra. Điều 16. Trách nhiệm của các cơ quan Nhà nước. 1/ Các cơ quan có thẩm quyền kiểm tra, xử lý hành chánh sản xuất và buôn bán hàng giả, in ấn, buôn bán trái phép nhãn hiệu, bao bì gồm: Ban chỉ đạo quản lý thị trường thành phố Công an thành phố Chi cục tiêu chuẩn đo lường chất lượng thành phố Sở Y tế thành phố Sở Văn hoá thông tin thành phố Hải quan thành phố UBND quận, huyện thuộc thành phố. 2/ Các cơ quan nêu trên thực hiện việc kiểm tra, xử lý theo chức năng nhiệm vụ của mình. 3/ Các cơ quan Nhà nước khác theo chức năng của mình có trách nhiệm phối hợp, giúp đỡ có thẩm quyền trong việc kiểm tra, xử lý việc sản xuất, buôn bán hàng giả. Chương IV.
- THỦ TỤC KIỂM TRA, XỬ LÝ VÀ KHEN THƯỞNG Điều 17. Khi phát hiện hàng giả và nhãn hiệu, bao bì được in ấn, buôn bán trái phép phải lập biên bản, niêm phong ngay số sản phẩm hàng hoá nghi vấn và lấy mẫu để kiểm nghiệm. Mẫu phải được chuyển từ cơ quan có trách nhiệm giám định trong vòng ba ngày kể từ khi niêm phong. Điều 18. 1/ Hàng giả cần phải được giám định chất lượng tại cơ quan Tiêu chuẩn do lường chất lượng hoặc tại Phòng thử nghiệm được công nhận. Hàng giả là hoá dược, thuốc chữa bệnh, nguyên liệu làm thuốc phải được giám định chất lượng tại Trạm kiểm nghiệm Sở Y tế hoặc phân viện kiểm nghiệm Bộ Y tế. 2/ Phương pháp lấy mẫu kiểm nghiệm dựa theo tiêu chuẩn về phương pháp lấy mẫu cho từng loại hàng hoá. Trường hợp chưa có tiêu chuẩn phương pháp lấy mẫu thì áp dụng theo phương pháp lấy mẫu đại diện. 3/ Đơn vị có trách nhiệm thử nghiệm phải báo kết luận của mình cho cơ quan đã gởi mẫu đến kiểm nghiệm trong thời hạn không quá 5 ngày so với thời gian cần thiết để kiểm nghiệm. Trong vòng 15 ngày kể từ ngày có kết luận kiểm nghiệm, cơ quan có thẩm quyền phải ra quyết định xử lý hoặc không xử lý đối với cơ sở sản xuất, kinh doanh đã bị kiểm tra. Điều 19. Cơ quan có thẩm quyền xử lý có trách nhiệm trích từ 1 - 30% tổng số tiền phạt thu được để thưởng cho tổ chức, cá nhân có công trong việc phát hiện tố giác, truy quét các vụ sản xuất, mua bán hàng giả. Trong tổng số tiền thưởng được sử dụng từ 1 – 15% thưởng cho người có công trực tiếp phát hiện. Sau khi trừ chi phí cần thiết cho việc kiểm tra, xử lý và tiền thưởng nêu trên, số tiền phạt còn lại phải được nộp vào ngân sách Nhà nước. Chương V. ĐIỀU KHOẢN THI HÀNH Điều 20. Trừ những qui định về hình thức xử lý và thẩm quyền xử lý nêu tại điều 11, 12, 13 bản qui định này, những vấn đề khác nếu không nêu trong văn bản này thì áp dụng theo pháp lệnh xử phạt vi phạm hành chánh ngày 07/12/1989 và Nghị định 140/HĐBT ngày 25/4/1991 về kiểm tra, xử lý việc sản xuất, buôn bán hàng giả.
- Điều 21. Các cơ quan có thẩm quyền nêu ở điều 16 có trách nhiệm phối hợp triển khai thực hiện qui định này. Điều 22. Qui định này có hiệu lực kể từ ngày ban hành. ỦY BAN NHÂN DÂN THÀNH PHỐ
CÓ THỂ BẠN MUỐN DOWNLOAD
-
Quyết định số 01/2008/QĐ-BNN
3 p |
113 |
22
-
Quyết định số 02/2008/QĐ-UBND
8 p |
61 |
9
-
Quyết định số 38/2008/QĐ-BNN
1 p |
69 |
9
-
Quyết định số 313/QĐ-BTC
26 p |
90 |
7
-
Quyết định số 12/2008/QĐ-UBND
2 p |
68 |
6
-
Quyết định số 14/2008/QĐ-UBND
2 p |
80 |
5
-
Quyết định số 362/QĐ-TCHQ
1 p |
71 |
4
-
Quyết định số 157/QĐ-BTC
2 p |
67 |
3
-
Quyết định số 44/QĐ-TTg
4 p |
87 |
3
-
Quyết định số 08/2008/QĐ-UBND
7 p |
54 |
3
-
Quyết định số 28/2008/QĐ-TTg
2 p |
114 |
3
-
Quyết định số 03/2008/QĐ-UBND
2 p |
66 |
2
-
Quyết định số 03/2008/QĐ-TTg
2 p |
70 |
2
-
Quyết định số 32/2008/QĐ-BNN
2 p |
61 |
2
-
Quyết định số 08/2008/QĐ-BTC
6 p |
86 |
2
-
Quyết định số 04/2008/QĐ-UBND
6 p |
67 |
2
-
Quyết định số 02/2008/QĐ-BCT
11 p |
61 |
1
-
Quyết định số 04/2008/QĐ-UBND
8 p |
56 |
1

Set-Cookie: TLDEVNamespace=4b3rhtp1ggshjq7ft0jucjft77; path=/; domain=.tailieu.vn; HttpOnly


markdown:
# Quyết định số 967/2006/QĐ-UBND
Chia sẻ: Truong Chi | Ngày: | Loại File: PDF | Số trang:2
46
lượt xem 2
download
lượt xem 2
download
![](http://image.tlvnimg.com/document/thumbnail/2009/20091023/truongbachi/80x100/556.jpg)
##
Quyết định số 967/2006/QĐ-UBND
Mô tả tài liệu
[Vui lòng tải xuống để xem tài liệu đầy đủ](javascript:void(0);)
Download
![](http://static.tlvnimg.com/b2013az/templates/version1/default/images/down16x21.png)
Quyết định số 967/2006/QĐ-UBND về việc thành lập Ban tổ chức Hội thảo quốc tế về “An toàn chất lượng sản phẩm cá tra, basa Việt Nam đáp ứng yêu cầu thị trường thực phẩm Thế giới” do Uỷ ban Nhân dân tỉnh An giang ban hành
Chủ đề:
Bình luận(0)
[Đăng nhập để gửi bình luận!](javascript:void(0);)
CÓ THỂ BẠN MUỐN DOWNLOAD

Set-Cookie: TLDEVNamespace=5di4mnks9d06kqcgophtug50n7; path=/; domain=.tailieu.vn; HttpOnly


markdown:
[](http://taimessenger.com/tai-messenger-cho-iphone-5.html)
![ Tải Messenger Cho iphone 5 phiên bản mới nhất](http://taimessenger.com/wp-content/uploads/2017/07/facebookmesenger.png)
#### Tải Messenger Cho iphone 5 phiên bản mới nhất
Hiện nay số lượng người sử dụng điện thoại iphone chiếm tới 40% trên tổng số lượng người dùng điện thoại và trong hãng điện thoại iphone thì iphone 5 là được nhiều người sử dụng nhất vì chi phí cho một chiếc điện thoại iphone không...666 0
[Tải về](http://taimessenger.com/messenger.apk)

WARC-Identified-Payload-Type: text/html

Set-Cookie: wordpress_logged_in_a1a69a0ec0af9b641dea471494bb36f2=deleted; expires=Thu, 01-Jan-1970 00:00:01 GMT; Max-Age=0; path=/; httponly

Vary: Accept-Encoding,User-Agent

Link: <http://taimessenger.com/wp-json/>; rel="https://api.w.org/", <http://taimessenger.com/?p=227>; rel=shortlink