Return to home page
Searching: Muskingum library catalog
In response to the COVID-19 outbreak, statewide lending via OhioLINK and SearchOhio has been suspended. OPAL member libraries have closed or are operating at reduced service levels. Please contact your library with specific lending requests or if you need assistance.

LEADER 00000cam  2200673Ki 4500 
001    797001963 
003    OCoLC 
005    20181023054106.8 
006    m     o  d         
007    cr cn||||||||| 
008    120628s2012    maua    o     001 0 eng d 
010    |z2012933622 
015    GBB1A8082|2bnb 
019    797208743|a810071434|a961569388|a962680376|a966355116
020    1118102282 
020    9781118102282 
020    9781118236215|q(electronic bk.) 
020    1118236211|q(electronic bk.) 
020    9781118223888|q(electronic bk.) 
020    1118223888|q(electronic bk.) 
020    9781118262160 
020    1118262166 
020    |z9781118102282 
035    (OCoLC)797001963|z(OCoLC)797208743|z(OCoLC)810071434
037    CL0500000166|bSafari Books Online 
037    2568A3E9-7C29-4206-8BFE-1DE48EB4DAE1|bOverDrive, Inc.
040    EUF|beng|epn|erda|cEUF|dB24X7|dUMI|dCOO|dC6I|dOCLCQ|dFDA
049    MAIN 
050  4 QA76.9.C55|bA85 2012eb 
082 04 005.75/85|223 
100 1  Atkinson, Paul|c(Software engineer)|0
245 10 Beginning Microsoft SQL Server 2012 programming /|cPaul 
       Atkinson, Robert Vieira. 
246 30 Microsoft SQL Server 2012 programming 
264  1 Indianapolis, IN :|bJohn Wiley & Sons,|c2012. 
300    1 online resource 
336    text|btxt|2rdacontent 
337    computer|bc|2rdamedia 
338    online resource|bcr|2rdacarrier 
340    |gpolychrome|2rdacc|0
347    text file|2rdaft|0
500    Includes index. 
505 0  1. RDBMS Basics: What Makes Up a SQL Server Database? -- 
       2. Learning the Tools of the Trade -- 3. The Foundation 
       Statements of T-SQL -- 4. Joins -- 5. Creating and 
       Altering Tables -- 6. Keys and Constraints -- 7. Adding 
       More to Your Queries -- 8. Being Normal: Normalization and
       Other Basic Design Issues -- 9. SQL Server Storage and 
       Index Structures -- 10. Views -- 11. Writing Scripts and 
       Batches -- 12. Stored Procedures -- 13. User-Defined 
       Functions -- 14. Transactions and Locks -- 15. Triggers --
       16. A Brief XML Primer -- 17. Business Intelligence 
       Fundamentals -- 18. BI Storage and Reporting Resources -- 
       19. Reporting for Duty, Sir! A look at Reporting Services 
       -- 20. Getting Integrated with Integration Services -- 21.
       Playing Administrator. 
505 00 |g1.|tRDBMS Basics: What Makes Up a SQL Server Database? -
       -|tAn Overview of Database Objects --|tThe Database Object
       --|tThe Transaction Log --|tThe Most Basic Database Object
       : Table --|tFilegroups --|tDiagrams --|tViews --|tStored 
       Procedures --|tUser-Defined Functions --|tSequences --
       |tUsers and Roles --|tRules --|tDefaults --|tUser-Defined 
       Data Types --|tFull-Text Catalogs --|tSQL Server Data 
       Types --|tNULL Data --|tSQL Server Identifiers for Objects
       --|tWhat Gets Named? --|tRules for Naming --|tSummary --
       |g2.|tLearning the Tools of the Trade --|tGetting Help 
       with Books Online --|tSQL Server Configuration Manager --
       |tService Management --|tNetwork Configuration --|tThe 
       Protocols --|tOn to the Client --|tSQL Server Management 
       Studio --|tGetting Started with the Management Studio --
       |tInteracting Through the Query Window --|tSQL Server Data
       Tools (formerly BIDS) --|tSQL Server Integration Services 
       (SSIS) --|tSQL Server Reporting Services (SSRS) --|tSQL 
       Server Analysis Services (SSAS) --|tBulk Copy Program 
       (BCP) --|tSQL Server Profiler --|tsqlcmd --|tPowerShell --
       |tSummary --|g3.|tThe Foundation Statements of T-SQL --
       |tGetting Started with a Basic SELECT Statement --|tThe 
       SELECT Statement and FROM Clause --|tThe WHERE Clause --
       |tORDER BY --|tAggregating Data Using the GROUP BY Clause 
       --|tPlacing Conditions on Groups with the HAVING Clause --
       |tOutputting XML Using the FOR XML Clause --|tMaking Use 
       of Hints Using the OPTION Clause --|tThe DISTINCT and ALL 
       Predicates --|tAdding Data with the INSERT Statement --
       |tMultirow Inserts --|tThe INSERT INTO ... SELECT 
       Statement --|tChanging What You've Got with the UPDATE 
       Statement --|tThe DELETE Statement --|tSummary --|g4.
       |tJoins --|tCombining Table Data with JOINs --|tSelecting 
       Matching Rows with INNER JOIN --|tHow an INNER JOIN Is 
       Like a WHERE Clause --|tRetrieving More Data with OUTER 
       JOIN --|tThe Simple OUTER JOIN --|tDealing with More 
       Complex OUTER JOINs --|tSeeing Both Sides with FULL JOINs 
       --|tUnderstanding CROSS JOINs --|tExploring Alternative 
       Syntax for Joins --|tAn Alternative INNER JOIN --|tAn 
       Alternative OUTER JOIN --|tAn Alternative CROSS JOIN --
       |tStacking Results with UNION --|tSummary --|g5.|tCreating
       and Altering Tables --|tObject Names in SQL Server --
       |tSchema Name (aka Ownership) --|tThe Database Name --
       |tNaming by Server --|tReviewing the Defaults --|tThe 
       CREATE Statement --|tCREATE DATABASE --|tBuilding a 
       Database --|tCREATE TABLE --|tThe ALTER Statement --
       |tALTER DATABASE --|tALTER TABLE --|tThe DROP Statement --
       |tUsing the GUI Tool --|tCreating a Database Using the 
       Management Studio --|tBacking into the Code: Creating 
       Scripts with the Management Studio --|tSummary --|g6.
       |tKeys and Constraints --|tTypes of Constraints --|tDomain
       Constraints --|tEntity Constraints --|tReferential 
       Integrity Constraints --|tConstraint Naming --|tKey 
       Constraints --|tPrimary Key Constraints --|tForeign Key 
       Constraints --|tUNIQUE Constraints --|tCHECK Constraints -
       -|tDEFAULT Constraints --|tDefining a DEFAULT Constraint 
       in Your CREATE TABLE Statement --|tAdding a DEFAULT 
       Constraint to an Existing Table --|tDisabling Constraints 
       --|tIgnoring Bad Data When You Create the Constraint --
       |tTemporarily Disabling an Existing Constraint --|tRules 
       and Defaults -- Cousins of Constraints --|tRules --
       |tDropping Rules --|tDefaults --|tDropping Defaults --
       |tDetermining Which Tables and Data Types Use a Given Rule
       or Default --|tTriggers for Data Integrity --|tChoosing 
       What to Use --|tSummary. 
505 00 |g7.|tAdding More to Your Queries --|tWhat Is a Subquery? 
       --|tBuilding a Nested Subquery --|tBuilding Correlated 
       Subqueries --|tHow Correlated Subqueries Work --|tDealing 
       with NULL Data -- the ISNULL Function --|tDerived Tables -
       -|tUsing Common Table Expressions (CTEs) --|tUsing the 
       WITH Keyword --|tUsing Multiple CTEs --|tRecursive CTEs --
       |tUsing the EXISTS Operator --|tFiltering with EXISTS --
       |tUsing EXISTS in Other Ways --|tMixing Data Types: CAST 
       and CONVERT --|tSynchronizing Data with the MERGE Command 
       --|tThe Merge Command in Action --|tA Brief Look at BY 
       TARGET versus BY SOURCE --|tGathering Affected Rows with 
       the OUTPUT Clause --|tThrough the Looking Glass: Windowing
       Functions --|tROW_ NUMBER --|tRANK, DENSE_ RANK, and NTILE
       --|tOne Chunk at a Time: Ad Hoc Query Paging --
       |tPerformance Considerations --|tMeasuring Performance --
       |tJOINs versus Subqueries versus CTEs versus ... --
       |tSummary --|g8.|tBeing Normal: Normalization and Other 
       Basic Design Issues --|tUnderstanding Tables --|tKeeping 
       Your Data " Normal" --|tBefore the Beginning --|tThe First
       Normal Form --|tThe Second Normal Form --|tThe Third 
       Normal Form --|tOther Normal Forms --|tUnderstanding 
       Relationships --|tOne-to-One --|tZero or One-to-One --
       |tOne-to-One or Many --|tOne-to-Zero, One, or Many --
       |tMany-to-Many --|tDiagramming Databases --|tTables --
       |tCreating Relationships in Diagrams --|tDenormalization -
       -|tBeyond Normalization --|tKeep It Simple --|tChoosing 
       Data Types --|tErr on the Side of Storing Things --
       |tDrawing Up a Quick Example --|tCreating the Database --
       |tAdding the Diagram and the Initial Tables --|tAdding the
       Relationships --|tAdding Some Constraints --|tSummary --
       |g9.|tSQL Server Storage and Index Structures --|tSQL 
       Server Storage --|tThe Database --|tThe Extent --|tThe 
       Page --|tRows --|tSparse Columns --|tUnderstanding Indexes
       --|tB-Trees --|tHow Data Is Accessed in SQL Server --
       |tCreating, Altering, and Dropping Indexes --|tThe CREATE 
       INDEX Statement --|tCreating XML Indexes --|tImplied 
       Indexes Created with Constraints --|tCreating Indexes on 
       Sparse and Geospatial Columns --|tChoosing Wisely: 
       Deciding Which Index Goes Where and When --|tSelectivity -
       -|tWatching Costs: When Less Is More --|tChoosing That 
       Clustered Index --|tColumn Order Matters --|tCovering 
       Indexes --|tFiltered Indexes --|tALTER INDEX --|tDropping 
       Indexes --|tTaking a Hint from the Query Plan --|tWhy 
       Isn't Your Index Being Used? --|tUse the Database Engine 
       Tuning Advisor --|tMaintaining Your Indexes --
       |tFragmentation --|tIdentifying Fragmentation versus 
       Likelihood of Page Splits --|tSummary --|g10.|tViews --
       |tCreating Simple Views --|tViews as Filters --|tEditing 
       Views with T-SQL --|tDropping Views --|tCreating and 
       Editing Views in the Management Studio --|tCreating Views 
       in Management Studio --|tEditing Views in the Management 
       Studio --|tAuditing: Displaying Existing Code --
       |tProtecting Code: Encrypting Views --|tAbout Schema 
       Binding --|tMaking Your View Look Like a Table with VIEW_ 
       METADATA --|tIndexed (Materialized) Views --|tIndexing an 
       Aggregate View --|tSummary --|g11.|tWriting Scripts and 
       Batches --|tUnderstanding Script Basics --|tSelecting a 
       Database Context with the USE Statement --|tDeclaring 
       Variables --|tSetting the Value in Your Variables --
       |tReviewing System Functions --|tRetrieving IDENTITY 
       Values --|tGenerating SEQUENCES --|tUsing @@ROWCOUNT --
       |tGrouping Statements into Batches --|tA Line to Itself --
       |tEach Batch Is Sent to the Server Separately --|tGO Is 
       Not a T-SQL Command --|tErrors in Batches --|tWhen to Use 
       Batches --|tRunning from the Command Prompt: sqlcmd --
       |tDynamic SQL: Using the EXEC Command --|tGenerating Your 
       Code on the Fly --|tUnderstanding the Dangers of Dynamic 
       SQL --|tUsing Control-of-Flow Statements --|tThe IF ... 
       ELSE Statement --|tThe CASE Statement --|tLooping with the
       WHILE Statement --|tThe WAITFOR Statement --|tDealing with
       Errors with TRY/CATCH Blocks --|tSummary --|g12.|tStored 
       Procedures --|tCreating the Sproc: Basic Syntax --|tAn 
       Example of a Basic Sproc --|tChanging Stored Procedures 
       with ALTER --|tDropping Sprocs --|tParameterizing Sprocs -
       -|tDeclaring Parameters --|tConfirming Success or Failure 
       with Return Values --|tHow to Use RETURN --|tMore on 
       Dealing with Errors --|tHandling Inline Errors --|tMaking 
       Use of @@ERROR --|tUsing @@ERROR in a Sproc --|tHandling 
       Errors Before They Happen --|tManually Raising Errors --
       |tRe-throwing Errors --|tAdding Your Own Custom Error 
       Messages --|tWhat a Sproc Offers --|tCreating Callable 
       Processes --|tUsing Sprocs for Security --|tSprocs and 
       Performance --|tExtended Stored Procedures (XPs) --|tA 
       Brief Look at Recursion --|tDebugging --|tStarting the 
       Debugger --|tParts of the Debugger --|tTaking a Break: 
       Breakpoints --|tUsing the Debugger Once It's Started --
       |tUnderstanding .NET Assemblies --|tWhen to Use Stored 
       Procedures --|tSummary. 
505 00 |g13.|tUser-Defined Functions --|tWhat a UDF Is --|tUDFs 
       Returning a Scalar Value --|tUDFs That Return a Table --
       |tInline UDFs --|tUnderstanding Determinism --|tDebugging 
       User-Defined Functions --|tUsing .NET in a Database World 
       --|tSummary --|g14.|tTransactions and Locks --
       |tUnderstanding Transactions --|tACID Transactions --
       |tIntroducing Transaction Operations --|tUsing BEGIN TRAN 
       --|tUsing COMMIT TRAN --|tUsing ROLLBACK TRAN --|tUsing 
       SAVE TRAN --|tHow the SQL Server Log Works --|tUsing the 
       Log for Failure and Recovery --|tActivating Implicit 
       Transactions --|tUnderstanding Locks and Concurrency --
       |tClarifying the Purpose of Locks --|tDefining Lockable 
       Resources --|tLock Escalation and Lock Effects on 
       Performance --|tUnderstanding Lock Modes --|tClarifying 
       Lock Compatibility --|tSpecifying a Specific Lock Type -- 
       Optimizer Hints --|tSetting the Isolation Level --
       |tSetting READ COMMITTED --|tSetting READ UNCOMMITTED --
       |tSetting REPEATABLE READ --|tSetting SERIALIZABLE --
       |tSetting SNAPSHOT --|tDealing with Deadlocks (aka "a 
       1205") --|tHow SQL Server Figures Out There's a Deadlock -
       -|tHow Deadlock Victims Are Chosen --|tAvoiding Deadlocks 
       --|tSummary --|g15.|tTriggers --|tWhat Is a Trigger? --
       |tON --|tWITH ENCRYPTION --|tFOR|tThe FOR|tNOT FOR 
       REPLICATION --|tAS --|tUsing Triggers for Data Integrity 
       Rules --|tDealing with Requirements Sourced from Other 
       Tables --|tUsing Triggers to Check the Delta of an Update 
       --|tUsing Triggers for Custom Error Messages --|tOther 
       Common Uses for Triggers --|tOther Trigger Issues --
       |tTriggers Can Be Nested --|tTriggers Can Be Recursive --
       |tTriggers Don't Prevent Architectural Changes --
       |tTriggers Can Be Turned Offwithout Being Removed --
       |tTrigger Firing Order --|tINSTEAD OF Triggers --
       |tPerformance Considerations --|tTriggers Are Reactive 
       Rather Than Proactive --|tTriggers Don't Have Concurrency 
       Issues with the Process That Fires Them --|tUsing IF 
       UPDATE() and COLUMNS_UPDATED --|tKeep It Short and Sweet -
       -|tDon't Forget Triggers When Choosing Indexes --|tTry Not
       to Roll Back within Triggers --|tDropping Triggers --
       |tDebugging Triggers --|tSummary --|g16.|tA Brief XML 
       Primer --|tXML Basics --|tParts of an XML Document --
       |tNamespaces --|tElement Content --|tBeing Valid versus 
       Being Well Formed -- Schemas and DTDs --|tWhat SQL Server 
       Brings to the Party --|tDefining a Column as Being of XML 
       Type --|tXML Schema Collections --|tCreating, Altering, 
       and Dropping XML Schema Collections --|tXML Data Type 
       Methods --|tEnforcing Constraints Beyond the Schema 
       Collection --|tRetrieving Relational Data in XML Format --
       |tRAW --|tAUTO --|tEXPLICIT --|tPATH --|tOPENXML --|tA 
       Brief Word on XSLT --|tSummary --|g17.|tBusiness 
       Intelligence Fundamentals --|tWhat Is Business 
       Intelligence? --|tBI Is Better Than the Alternative --
       |tMaking Decisions Based on Data --|tFive Experts, Five 
       Opinions --|tPast Performance Predicts Future Behavior --
       |tWho Uses BI? --|tThose Who Forget History: The Data 
       Warehouse --|tThe Purpose of the Data Warehouse --|tOLTP 
       versus OLAP --|tKimball versus Inmon --|tDimensional 
       Modeling: Why Be Normal? --|tMeasures and Metrics --
       |tFacts --|tDimensions --|tETLs --|tSourcing Your Data --
       |tEnforcing Conformity --|tResolving Conflicts by Defining
       Authoritative Data --|tTwo, Three, or More Stages --
       |tDealing with Concurrency During ETLs --|tCaching Your 
       Extract -- The Operational Data Store (ODS) --|tMaking 
       Your Data Actionable: BI Reporting Techniques --|tGoals --
       |tKey Performance Indicators --|tDashboards --|tScorecards
       --|tDetail Reports --|tDrill-Down --|tDrill-Through --|tAd
       Hoc Reporting --|tSummary --|g18.|tBI Storage and 
       Reporting Resources --|tBI in T-SQL --|tIntroducing the 
       AdventureWorks Data Warehouse --|tUsing T-SQL Analysis 
       Functions --|tColumnstore Indexes --|tSQL Server Analysis 
       Services, or How I Learned to Stop Worrying and Love the 
       Cube --|tUnderstanding SSAS Modeling --|tBuilding Your 
       First Cube --|tData Sources --|tData Source Views --
       |tCubes --|tMeasure Groups --|tDimensions --|tThe Rest of 
       the Cube --|tSelf-Service BI: User Tools --|tReport 
       Builder --|tPowerPivot: Lightweight BI with SharePoint and
       Excel --|tPower View --|tSummary --|g19.|tReporting for 
       Duty, Sir! A look at Reporting Services --|tReporting 
       Services 101 --|tUnderstanding the SSRS Report Lifecycle -
       -|tDeveloping Reports in SSRS --|tManaging Your Reports --
       |tDelivering Reports to Users --|tUnderstanding the 
       Reporting Services Architecture --|tSSDT: Report Designer 
       --|tSSRS Windows Service --|tReport Manager --|tReport 
       Builder --|tReport Viewer --|tBuilding Simple Report 
       Models --|tCreating a Project --|tAdding to Your Data 
       Model --|tBuilding and Deploying Your Data Model --
       |tReport Creation --|tReport Server Projects --|tBuilding 
       a Report Server Project --|tDeploying the Report --
       |tSummary --|g20.|tGetting Integrated with Integration 
       Services --|tUnderstanding the Problem --|tUsing the 
       Import/Export Wizard to Generate Basic Packages --
       |tStarting the Wizard --|tChoosing Your Data Sources --
       |tCompleting the Wizard --|tExamining Package Basics --
       |tConnection Managers --|tThe Package Editor Pane --
       |tExecuting Packages --|tExecuting a Package inside the 
       Development Studio --|tExecuting within SSMS --|tUsing the
       Execute Package Utility --|tExecuting Using the SQL Server
       Agent --|tExecuting a Package from within a Program --|tA 
       Final Word on Packages --|tSummary --|g21.|tPlaying 
       Administrator --|tScheduling Jobs --|tCreating an Operator
       --|tCreating Jobs and Steps --|tLogins and Users --
       |tBackup and Recovery --|tCreating a Backup --|tRecovery 
       Models --|tRecovery --|tIndex Maintenance --|tALTER INDEX 
       --|tPolicy Based Management --|tAutomating Administration 
       Tasks with PowerShell --|tWhat Is PowerShell? --
       |tInstalling and Enabling PowerShell --|tCmdlets and 
       Modules --|tSqlps --|tDeployment and Execution --
520 8  Annotation|bGet up to speed on the extensive changes to 
       the newest release of Microsoft SQL ServerThe 2012 release
       of Microsoft SQL Server changes how you develop 
       applications for SQL Server. With this comprehensive 
       resource, SQL Server authority Robert Vieira presents the 
       fundamentals of database design and SQL concepts, and then
       shows you how to apply these concepts using the updated 
       SQL Server. Publishing time and date with the 2012 release,
       Beginning Microsoft SQL Server 2012 Programming begins 
       with a quick overview of database design basics and the 
       SQL query language and then quickly proceeds to show you 
       how to implement the fundamental concepts of Microsoft SQL
       Server 2012. Youll explore the key additions and changes 
       to this newest version, including conditional action 
       constructs, enhanced controls for results paging, 
       application integration with SharePoint and Excel, and 
       development of BI applications. Covers new features such 
       as SQL Azure for cloud computing, clientconnectivity 
       enhancements, security and compliance, data replication, 
       and data warehouse performance improvementsAddresses 
       essential topics including managing keys, writing scripts,
       and working with store proceduresShares helpful techniques
       for creating and changing tables, programming with XML, 
       and using SQL Server Reporting and Integration 
       ServicesBeginning Microsoft SQL Server 2012 Programming 
       demystifies even the most difficult challenges you may 
       face with the new version of Microsoft SQL Server. 
630 00 SQL server.|0
650  0 Client/server computing.|0
655  4 Electronic books. 
700 1  Vieira, Robert.|0
776 08 |iPrint version:|aAtkinson, Paul.|tBeginning Microsoft SQL
       Server 2012 programming.|dIndianapolis, IN : John Wiley & 
990    ProQuest Safari|bO'Reilly Safari Learning Platform: 
       Academic edition|c2018-10-22|yNew collection 
990    ProQuest ebrary|bebrary Academic Complete|c2017-08-11
       |yRemoved from collection ebrary.ebooks|5MTU 
990    ProQuest ebrary|bebrary Academic Complete|c2017-06-09
       |yMaster record variable field(s) change: 505|5MTU 
990    ProQuest ebrary|bebrary Academic Complete|c2017-04-20|5MTU
View online

If you experience difficulty accessing or navigating this content, please contact the OPAL Support Team