<?xml version="1.0" encoding="UTF-8"?>
<schedule>
  <conference>
    <title>PGCon 2011</title>
    <subtitle>The PostgreSQL Conference</subtitle>
    <venue>University of Ottawa</venue>
    <city>Ottawa</city>
    <start>2011-05-17</start>
    <end>2011-05-21</end>
    <days>5</days>
    <release>Final (2011.06.11)</release>
    <day_change>09:00</day_change>
    <timeslot_duration>00:30</timeslot_duration>
  </conference>
  <day date="2011-05-17" index="1">
    <room name="DMS 1140">
    </room>
    <room name="DMS 1150">
    </room>
    <room name="DMS 1160">
    </room>
    <room name="DMS 1110">
    </room>
    <room name="DMS 1120">
      <event id="305">
        <start>09:00</start>
        <duration>03:00</duration>
        <room>DMS 1120</room>
        <slug></slug>
        <title>Using The PostgreSQL System Catalogs</title>
        <subtitle>Database Introspection with PostgreSQL</subtitle>
        <track>DBA</track>
        <type>workshop</type>
        <language>en</language>
        <abstract>The PostgreSQL system catalogs store metadata about SQL objects such as tables, columns, functions, schemas, and more. This talk will explore the organization and structure of the system catalogs and explain how you can use these catalogs to manage and tune your database.</abstract>
        <description>We'll cover applications such as (1) getting a list of all tables that have no indices, (2) determining table and database sizes on disk, and (3) monitoring table, session, and background writer activity, as well as the internal structure of the catalogs and how they're used by the database system.</description>
        <persons>
          <person id="140">Robert Haas</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="336">
        <start>13:00</start>
        <duration>03:00</duration>
        <room>DMS 1120</room>
        <slug></slug>
        <title>PostgreSQL Performance Pitfalls</title>
        <subtitle>Keeping yourself out of the pit</subtitle>
        <track>Performance</track>
        <type>workshop</type>
        <language>en</language>
        <abstract>PostgreSQL is a database system that can deliver excellent performance for a wide variety of applications.  But it's easy to run into an issue that keeps you from seeing its full potential.  There are a few basic PostgreSQL configuration and use misunderstandings that cause most of the early performance issues administrators and developers encounter.</abstract>
        <description>This talk covers the most common performance problems seen in real-world PostgreSQL deployment.  It briefly summarizes each and points out the basics of how to avoid them.  It's like navigating a minefield:  you'll progress though a lot faster if you can start by knowing what the mines look like.

With PostgreSQL 9.0 featuring all new built-in replication and query distribution features, the timing has never been better to consider what a serious jump into using PostgreSQL would look like.  Getting the performance related aspects right can be one of the most stressful parts of such a migration, particularly if you're new to the database and its quirks.  Follow the suggestions here, and you can build your database to postpone many of these slowdowns until you've already proven your application is a success.</description>
        <persons>
          <person id="110">Greg Smith</person>
        </persons>
        <links>
        </links>
      </event>
    </room>
    <room name="Out and about">
    </room>
    <room name="Royal Oak">
    </room>
    <room name="The Velvet Room">
    </room>
    <room name="DMS 3105">
    </room>
    <room name="DMS 8161">
    </room>
  </day>
  <day date="2011-05-18" index="2">
    <room name="DMS 1140">
    </room>
    <room name="DMS 1150">
    </room>
    <room name="DMS 1160">
    </room>
    <room name="DMS 1110">
    </room>
    <room name="DMS 1120">
      <event id="340">
        <start>09:00</start>
        <duration>03:00</duration>
        <room>DMS 1120</room>
        <slug></slug>
        <title>Life with Object-Relational Mappers</title>
        <subtitle>Or, how I stopped worrying and learned to love the ORM</subtitle>
        <track>DBA</track>
        <type>workshop</type>
        <language>en</language>
        <abstract>Object-Relational Mappers (ORMs) are the primary interface that application programmers now use to interact with SQL databases. Any DBA can list the problems that they create, but how can we move on to solutions that don't involve a complete reengineering the ORM-database interaction paradigm? Rather than simply declaim that ORMs are bad, let's find a way of mitigating the problems that existing ORMs create.</abstract>
        <description>The database community seems to have been blindsided by the rise of Object-Relational Mappers (ORMs) as the primary database interface technology, even though ORMs themselves have been around for years (the core concepts date to the early 1990s and before). The problems with ORMs are real: Poor-quality SQL, schemas that are not well-matched to the capabilities of the database, and database access patterns that are hugely inefficient.

Yet ORMs are here to stay, and we must deal with ORMs that currently exist, rather than the theoretical ORMs we wish we had. As database architects and engineers, ORMs are now part of our client universe, and we need to understand them and find ways of working with, rather than against them.

We'll talk about why ORMs have the characteristics that they do, and why they appeal so strongly to application programmers over direct-SQL model. Using real-life ORMs, we'll explore ways that database architects can guide the development of ORM-based applications in a way that mitigate the problems that an ORM can create in database interaction. These include ORM-friendly changes to the application, ORM-invisible changes to the database, and (when required) spot alternations to the application to avoid disasters.

</description>
        <persons>
          <person id="190">Christophe Pettus</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="357">
        <start>13:00</start>
        <duration>03:00</duration>
        <room>DMS 1120</room>
        <slug></slug>
        <title>Trees and Graphs in the database</title>
        <subtitle>RDBMS in the social networks age</subtitle>
        <track>Advanced Features</track>
        <type>workshop</type>
        <language>en</language>
        <abstract>Despite the NoSQL movement trying to flag traditional databases as a dying breed, the RDBMS keeps evolving and adding new powerful weapons to its arsenal. In this talk we'll explore Common Table Expressions (SQL-99) and how SQL handles recursion, breaking the bi-dimensional barriers and paving the way to more complex data structures like trees and graphs, and how we can replicate features from social networks and recommendation systems. We'll also have a look at window functions (SQL:2003) and the advanced reporting features they make finally possible.</abstract>
        <description>The first part of this talk will cover several different techniques to model a tree data structure into a relational database: parent-child (adjacency list) model, materialized path, nested sets, nested intervals, hybrid models, Common Table Expressions.
Then we'll move one step forward and see how we can model a more complex data structure, i.e. a graph, with concrete examples from today's websites. Starting from real-world examples of social networks' and recommendation systems' features, and with the help of some graph theory, this talk will explain how to represent and traverse a graph in the database.
Finally, we will take a look at Window Functions and how they can be useful for data analytics and simple inline aggregations, among other things.

All the examples have been tested on PostgreSQL &gt;= 8.4</description>
        <persons>
          <person id="206">Lorenzo Alberton</person>
        </persons>
        <links>
          <link href="http://www.slideshare.net/quipo/trees-in-the-database-advanced-data-structures">Trees in the database - Slides</link>
          <link href="http://www.slideshare.net/quipo/rdbms-in-the-social-networks-age">Graphs in the database - Slides</link>
        </links>
      </event>
    </room>
    <room name="Out and about">
    </room>
    <room name="Royal Oak">
      <event id="379">
        <start>15:00</start>
        <duration>07:00</duration>
        <room>Royal Oak</room>
        <slug>registration</slug>
        <title>Registration pickup</title>
        <subtitle>The social way to register: at the pub</subtitle>
        <track></track>
        <type>other</type>
        <language>en</language>
        <abstract>Pick up your registration pack</abstract>
        <description>Stop by the Royal Oak Pub and get your registration pack. You'll help us avoid long line ups on Friday morning and you get to have a beer, and chat with your fellow attendees. We guarantee you'll spot someone famous.</description>
        <persons>
          <person id="1">Dan Langille</person>
        </persons>
        <links>
        </links>
      </event>
    </room>
    <room name="The Velvet Room">
    </room>
    <room name="DMS 3105">
    </room>
    <room name="DMS 8161">
    </room>
  </day>
  <day date="2011-05-19" index="3">
    <room name="DMS 1140">
      <event id="361">
        <start>10:00</start>
        <duration>01:00</duration>
        <room>DMS 1140</room>
        <slug></slug>
        <title>Database Scalability Patterns: Sharding for Unlimited Growth</title>
        <subtitle></subtitle>
        <track>Scaling Out</track>
        <type></type>
        <language></language>
        <abstract>Most people have come to understand simple replication based horizontal scale-out, but while this technique works pretty well for some read loads, there are system where either the amount of data involved is too great for a single system, or the write based load goes beyond the capacity of a single machine. In these cases we must turn to complex systems of federated databases to build database systems that can sustain perpetual growth. </abstract>
        <description>"Sharding" is a buzz word losing some of it's buzz, and that's a good thing. For many people building read-based scaleout systems is all they will ever need, but if it isn't where do you turn? In this talk I'll focus specifically on large scale, application based scale out being used by some of todays largest internet infrastructures. We'll focus on understanding the pattern underlying these systems, how they are implemented (including discussions on MySQL vs. Postgres as a backing store), and how to manage the infrastructure once you've built it. It isn't for the faint of heart, but if you plan to build large scale systems on commodity hardware, you need to know what has worked for others in the past. </description>
        <persons>
          <person id="20">Robert Treat</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="368">
        <start>11:30</start>
        <duration>01:00</duration>
        <room>DMS 1140</room>
        <slug></slug>
        <title>Review of Patch Reviewing</title>
        <subtitle>How to Review Patches for PostgreSQL</subtitle>
        <track>Hacking</track>
        <type>lecture</type>
        <language></language>
        <abstract>Patch reviewing is an important part of moving PostgreSQL forward.  It's critical for anyone submitting patches to PostgreSQL to also understand how to review patches, too.  This talk will go through the steps of patch review, including the most important piece- code review.</abstract>
        <description>PostgreSQL, more than most applications, must be stable and reliable.  Crashes are just not acceptable, ever.  Data loss must be prevented.  Add to this the many complexities of meeting the requirements of ACID and SQL, and it's clear that the code in PostgreSQL needs to be reviewed very carefully.  We depend on the committers to do final review and commit, but they are a very finite resource.  The PostgreSQL community has an excellent approach to scaling up our committer resources- make sure what they're reviewing is of good quality.

We'll talk about how to become a reviewer, how to use the CommitFest application, what makes a good pre-committer review, some tricks to doing reviews, and what to look for when doing a code review.</description>
        <persons>
          <person id="114">Stephen Frost</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="353">
        <start>13:30</start>
        <duration>01:00</duration>
        <room>DMS 1140</room>
        <slug></slug>
        <title>Real Federation Database System leveraging PostgreSQL FDW</title>
        <subtitle></subtitle>
        <track>Advanced Features</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>Federation Database System solves transparent access to heterogeneous DBMS to realize  Optimized Database schema design according to optimized business process. Our database team develops Real Federation Database System leveraging PostgreSQL FDW. This federation system enhances the current optimization of Foreign Scan and adds Foreign Data Wrapper for another RDBMS such as Oracle and Microsoft SQL Server.</abstract>
        <description>We implement Federation Database System using PostgreSQL FDW and realize following things:
- Access heterogeneous external data source as local data 
- Location, Vendor and Platform Transparency
- Without change of existing system change
- Real-time Data Reference and Data Update
These features give us various advantages as follows:
- Optimization of Business Process across multiple business systems
- Integrated Database access
- Avoidance of redundant data management
My presentation explains the development technique for Federation Database System based on PostgreSQL FDW. It includes the optimization technique for heterogeneous distributed database access and integration technique of Foreign Data Wrapper to heterogeneous RDBMS (e.g. Oracle and Microsoft SQL Server) and so on. And also we would like to discuss the requirements for new Federation Database System for this cloud era.</description>
        <persons>
          <person id="204">Yotaro Nakayama</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="287">
        <start>15:00</start>
        <duration>01:00</duration>
        <room>DMS 1140</room>
        <slug></slug>
        <title>Understanding PostgreSQL LWLocks</title>
        <subtitle></subtitle>
        <track>Hacking</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>In this session we take a look at the Light Weight Lock facility in PostgreSQL and the various lwlocks.</abstract>
        <description>PostgreSQL uses Light Weight Locks to manage PostgreSQL Locks. 
In this session we take 

* Describe the framework of PostgreSQL LWLocks facility 
  -&gt; Architecture of the LWLocks Framework
  -&gt; Lifecycle of an LWLock using its API
  -&gt; Understanding Exclusive and Shared  modes of lwlock
  -&gt; Internals of LWLock Wait List
  -&gt; Ways to monitors the events related to LWLocks

* Top LWLocks. 
 -&gt; WALInsertLock 
 -&gt; WALWriteLock
 -&gt; ProcArrayLock
 -&gt; SInvalReadLock
 -&gt; CLogControlLock
 -&gt; DynamicLWLocks


Once you start monitoring LWLocks, you will probably find one of the above locks as highly used or contended. We go a bit further in understanding what this lock means and the corrective actions to take to reduce the stress on the locks.


</description>
        <persons>
          <person id="79">Jignesh K. Shah</person>
        </persons>
        <links>
          <link href="http://jkshah.blogspot.com/2011/05/understanding-postgresql-lwlocks-pgcon.html">Presentation Slides</link>
        </links>
      </event>
      <event id="292">
        <start>16:30</start>
        <duration>01:00</duration>
        <room>DMS 1140</room>
        <slug></slug>
        <title>PostgreSQL Logging</title>
        <subtitle>How to get the most out of your activity log</subtitle>
        <track>DBA</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>Logs can tell you a lot about what's going on in your database:  which user logged in when, what queries they ran and how long they took, when the database restarted.  We'll walk through the various logging configuration options PostgreSQL offers to help you figure out how to get what you need in a format that's useful to you.  We'll also talk about what to do with your logs once you have them (hint:  you don't have to stay up at night reading through them!) and, time permitting, wrap up with a group discussion.</abstract>
        <description>Logging is an important part of your database monitoring suite, providing historical information for troubleshooting and forensic purposes:  which user logged in when, what queries they ran and how long they took, when the database restarted.  PostgreSQL offers different file format, message format, and message content options for logging.  These options can be kind of overwhelming for the first-time user.  We'll walk through the various configuration parameters to help you figure out how to get what you need in a format that's useful to you.  Then we'll discuss some solutions (pgFouine and friends) for extracting information from your logs.  If there's time, I really like to have a group discussion at the end of my talks - so bring your configs, logs, and war stories!</description>
        <persons>
          <person id="185">Gabrielle Roth</person>
        </persons>
        <links>
        </links>
      </event>
    </room>
    <room name="DMS 1150">
    </room>
    <room name="DMS 1160">
      <event id="373">
        <start>09:00</start>
        <duration>01:00</duration>
        <room>DMS 1160</room>
        <slug>keynote</slug>
        <title>PostGIS Knows Where You Are</title>
        <subtitle>Should you be Worried?</subtitle>
        <track>Plenary</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>Paul Ramsey has been working with geospatial software for more than 10
years, as programmer and consultant. He co-founded the PostGIS spatial
database project in 2001, and is currently an active developer and
member of the project steering committee. In 2008, Paul received the
Sol Katz Award for achievement in open source geospatial software.
</abstract>
        <description>Geolocation is a hot topic in technology right now,
so this topic will offer a tour of the terrain: what geolocation is
being used for, where PostGIS came from, how it uses PostgreSQL, who
is using it, and the technology challenges that PostGIS (and by
extension PostgreSQL) face in the future as use cases continue to push
more and more data through the system.
</description>
        <persons>
          <person id="208">Paul Ramsey </person>
        </persons>
        <links>
        </links>
      </event>
      <event id="351">
        <start>10:00</start>
        <duration>01:00</duration>
        <room>DMS 1160</room>
        <slug></slug>
        <title>9.1 Mystery Tour</title>
        <subtitle>What's in the upcoming version</subtitle>
        <track>9.1 Features</track>
        <type></type>
        <language></language>
        <abstract>SQL/MED, Sync Rep, SSI, Streaming Backups, SE-PostgreSQL, Writeable CTEs, Range Types, per-Column Collations, EXTENSIONs, directory archives, checkpoint goggles, VIEW triggers, extensible ENUMs, and more.</abstract>
        <description>What are these things? Why should they matter to you?  Which of them are in 9.1 and which aren't?</description>
        <persons>
          <person id="34">Josh Berkus</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="343">
        <start>11:30</start>
        <duration>01:00</duration>
        <room>DMS 1160</room>
        <slug></slug>
        <title>Best practices with Ora2Pg</title>
        <subtitle>Migrating Oracle databases to PostgresQL</subtitle>
        <track>Case Studies</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>Ora2Pg is a GPLv3 licensed tool used to help migrate an Oracle database to a PostgreSQL compatible database. Ora2Pg can be used from reverse engineering Oracle database to huge enterprise database migration or simply to replicate some Oracle data into a PostgreSQL database.
</abstract>
        <description>This talk by the author of Ora2Pg will start with an introduction to the project and its history. We will continue with the best practices using Ora2Pg for Oracle to PostgreSQL migration. We will cover much of the functionalities coming in the v7.0 release which contains significant speed improvement and new features. An overview of the future development of Ora2Pg will be provided. 

The talk will also cover the basic techniques and gotchas around migrating from Oracle to PostgreSQL.</description>
        <persons>
          <person id="209">Gurjeet Singh</person>
        </persons>
        <links>
          <link href="http://ora2pg.darold.net/"> Home page of the project</link>
        </links>
      </event>
      <event id="366">
        <start>13:30</start>
        <duration>01:00</duration>
        <room>DMS 1160</room>
        <slug>bigpostgres</slug>
        <title>Maintaining Terabytes</title>
        <subtitle>10 Things to Watch Out For When PostgresSQL Gets Big</subtitle>
        <track>Performance</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>Size can creep up on you. Some day you may wake up to a multi-terabyte Postgres system handling over 3000 tps staring you down. Learn the best ways to manage these systems as they grow, and find out what new features in 9.0 have made life easier for administrators and application developers working with big data.</abstract>
        <description>Size can creep up on you. Some day you may wake up to a multi-terabyte Postgres system handling over 3000 tps staring you down. Learn the best ways to manage these systems as they grow, and find out what new features in 9.0 have made life easier for administrators and application developers working with big data.

This talk will lead you through solutions to problems Postgres faces when it gets big: backups, transaction wraparound, bloat, huge catalogs and upgrades. You need to monitor the right things, find the gems in DBA-friendly database functions and catalog tables, and know the right places to look to spot problems early. We&#8217;ll also go over monitoring best practices and open source tools to get the job done.

Working with multiple versions of Postgres back to version 8.2 will be included, and as well as tips on making the most out of new features in 9.0. War stories will be taken from real-world work with Emma, an email marketing company with a few large databases.</description>
        <persons>
          <person id="112">Selena Deckelmann</person>
        </persons>
        <links>
          <link href="http://">http://</link>
        </links>
      </event>
      <event id="352">
        <start>15:00</start>
        <duration>01:00</duration>
        <room>DMS 1160</room>
        <slug></slug>
        <title>Parallel  Image  Searching Using  PostgreSQL and PgOpenCL</title>
        <subtitle>Running PostgreSQL  Stored Procedures on  a GPU</subtitle>
        <track>Advanced Features</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>2D and 3D Image data is increasing important.  New 3D scanning devices are being used to map a variety of large and small spaces and objects. 
Large GIS data sets are being acquired with new scanners.  Computation photography allows the manipulation of images for many applications both scientific and social.  GPUs are increasingly being used to accelerate image based computations. This presentation illustrates how PostgreSQL can store and process images using GPU hosted stored procedures, written in OpenCL.</abstract>
        <description>This is an outline of my proposed slides

&#8226;	Title
&#8226;	Speaker&#8217;s Bio
o	  Brief biographical details of the speaker.
&#8226;	Talk Outline
o	  Overview the talks topics
&#8226;	Parallel  Universe
o	  Provides an over view of  what  GPU (highly parallel chips) will bring to the  DBMS world.
&#8226;	The power of GPU&#8217;s
o	  Describes the enormous computing power available from GPUs.
&#8226;	OpenCL   GPU/CPU Programming Language
o	  Describes the new OpenCL programming language that can be used for parallel programming for CPUs and GPUs.
&#8226;	PgOpenCL  a new PostgeSQL  Procedural Language
o	  Describes PgOpenCL a new PostgreSQL procedure language that allows stored procedures to be written in OpenCL.
&#8226;	Image Data Types
o	  Outlines 2D,and 3D image data types that are used to storage and processing of images.
&#8226;	Parallel  Image  searching
o	  Outlines the type of image filter functions that can be used to process images and extract information as SQL tables from images.
&#8226;	Future Directions
o	 Describes the future direction of parallel processing in databases.
&#8226;	Summary
o	 Summarized the main points  of the talk
&#8226;	Q &amp;A
o	 Time to answer question from the audience.


</description>
        <persons>
          <person id="203">Tim Child</person>
        </persons>
        <links>
          <link href="http://www.scribd.com/doc/55847299/PgCOn-2011-Parallel-Image-Searching">PgCon 2011 Slides</link>
          <link href="http://">http://</link>
          <link href="http://">http://</link>
        </links>
      </event>
      <event id="296">
        <start>16:30</start>
        <duration>01:00</duration>
        <room>DMS 1160</room>
        <slug></slug>
        <title>Securing PostgreSQL From External Attack</title>
        <subtitle></subtitle>
        <track>DBA</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>This talk explores the ways attackers with no authorized database access
can steal Postgres passwords, see database queries and results, and even
intercept database sessions and return false data. </abstract>
        <description>Postgres supports
features to eliminate all of these threats, but administrators must
understand the attack vulnerabilities to protect against them. This talk
covers all known Postgres external attack methods.
</description>
        <persons>
          <person id="38">Bruce Momjian</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="369">
        <start>17:30</start>
        <duration>01:00</duration>
        <room>DMS 1160</room>
        <slug>lightning</slug>
        <title>Lightning talks</title>
        <subtitle>Short sharp descriptions of short topics</subtitle>
        <track></track>
        <type>lightning</type>
        <language>en</language>
        <abstract>A regular feature, PGCon will have a Lightning talks session, with presentations on diverse topics.</abstract>
        <description>The format remains essentially the same: in a one hour period, audiences are entertained and informed by a rapid fire series of short talks on interesting new or on-going work by individuals or groups. Slides aer permitted, but not obligatory; pictures are highly recommended. Topic areas include new open source software projects, works in progress for future releases of existing projects, student projects, etc. Lightning talks topics this year may make good conference papers next year! 

The number of slots is limited, and experience suggests there will be more takers than slots. Sign up well in advance to be assured a spot. The session chair this year is Selena Deckelmann.
</description>
        <persons>
          <person id="56">Magnus Hagander</person>
          <person id="112">Selena Deckelmann</person>
        </persons>
        <links>
          <link href="http://wiki.postgresql.org/wiki/PgCon_2011_Lightning_talks">List of talks + slides</link>
        </links>
      </event>
    </room>
    <room name="DMS 1110">
    </room>
    <room name="DMS 1120">
      <event id="300">
        <start>10:00</start>
        <duration>01:00</duration>
        <room>DMS 1120</room>
        <slug></slug>
        <title>Data-driven cache invalidation </title>
        <subtitle></subtitle>
        <track>Applications</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>In todays world, nobody (should) deploy a web application facing the
internet without having a proper caching system in place. There are
many different solutions to choose from, from manual use of memcached
through framework integrated caching to external caches like Squid or
Varnish. Most modern frameworks come with integrated functionality for
at least one of these methods, and often more than one.</abstract>
        <description>However, they often relies on all traffic going through the same
framework to work properly - a caching layer in Rails is hard to share
with one in Django. This talk will show a way to break the design
rules of these frameworks just a little, and have the database help
solve this problem.

This talk will use a small application written in Python using Django
to illustrate the examples, but the method is language independent.
Unsurprisingly, the database used is PostgreSQL.</description>
        <persons>
          <person id="56">Magnus Hagander</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="297">
        <start>11:30</start>
        <duration>02:00</duration>
        <room>DMS 1120</room>
        <slug></slug>
        <title>MVCC Unmasked</title>
        <subtitle></subtitle>
        <track>Advanced Features</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>Multi-Version Concurrency Control (MVCC) allows Postgres to offer high
concurrency even during significant database read/write activity. MVCC
specifically offers behavior where "readers never block writers, and
writers never block readers".</abstract>
        <description>This talk explains how MVCC is implemented
in Postgres and highlights optimizations which minimize the downsides of
MVCC. This talk is for advanced users.

This is a two hour talk which extends into lunch.  There will be a short break to allow people to grab lunch and bring it back into the lecture hall.
</description>
        <persons>
          <person id="38">Bruce Momjian</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="303">
        <start>13:30</start>
        <duration>01:00</duration>
        <room>DMS 1120</room>
        <slug></slug>
        <title>How To Get Your PostgreSQL Patch Accepted</title>
        <subtitle>In short: -1 from me.  regards, tom lane</subtitle>
        <track>Hacking</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>Writing a PostgreSQL patch can be difficult, and getting it accepted can require even more work than writing it in the first place.</abstract>
        <description>Many people contribute to PostgreSQL each year, and these contributions are critical to PostgreSQL's ongoing success and continued improvement.  Patches are also regularly turned away for a variety of reasons.  In this talk, I'll discuss how to maximize your chances of a successful contribution and what to do next if your patch is rejected.</description>
        <persons>
          <person id="140">Robert Haas</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="307">
        <start>15:00</start>
        <duration>01:00</duration>
        <room>DMS 1120</room>
        <slug></slug>
        <title>NTT&#8217;s Case Report</title>
        <subtitle>Introduce PostgreSQL into reliable and large-scale telecommunication support system</subtitle>
        <track>Case Studies</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>We will present how to introduce PostgreSQL into NTT&#8217;s telecommunication systems. To inform the merit of PostgreSQL for IT system managers we evaluated its performance and showed applicable field of our production systems. To broaden the field we have resolved performance problems like as performance glitch at checkpoints and improved its usability with home-made tools such as pg_bulkload, pg_statsinfo and so on. All these efforts and their results are worth being shared with who plan and proceed PostgreSQL&#8217;s enterprise use.</abstract>
        <description>NTT group, which is the largest telecommunication career in Japan providing more than 120 million subscribers, has made effort introducing PostgreSQL to its production systems that support telecommunication. Such systems require as same performance and reliability as proprietary DBMSes provide, which shows PostgreSQL should be enhanced in many aspects for enterprise use.
We will present what kind of performance characters were required from production systems engineers and how we showed them. At first we evaluate PostgreSQL performance under TPC-C and TPC-W like workload to show its throughputs are enough for many systems. At the same time we found instability of response time and complex maintenance operation like VACUUM, which we thought be large obstacles for introduction. We tried to resolve them and they are finally cleared up by PostgreSQL 8.3. From the view point of usability, our production engineers pointed PostgreSQL lacked some essential utility tool such as fast data-loader and performance monitor. So we provided original open-source tools pg_bulkload and pg_statsinfo to meet such requirements.
Finally we will present improvement availability by PostgreSQL 9.0 and show expected applied systems that the feature should enable.
</description>
        <persons>
          <person id="192">Tetsuo Sakata</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="350">
        <start>16:30</start>
        <duration>01:00</duration>
        <room>DMS 1120</room>
        <slug></slug>
        <title>Hacking the Query Planner</title>
        <subtitle></subtitle>
        <track>Hacking</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>What does the planner do and why does it do it?  How can it be improved?</abstract>
        <description>This is a follow-on to Robert Haas's planner talk at PGCon 2010.  I plan to focus more on why and how the planner works, ie, present a developer's-eye view instead of a user's-eye view of what it does.  Topics will include the overall layout of the planner code, preprocessing, join search order, and cost estimation.  Hopefully attendees will come away encouraged to hack on the planner and help improve it.</description>
        <persons>
          <person id="202">Tom Lane</person>
        </persons>
        <links>
        </links>
      </event>
    </room>
    <room name="Out and about">
    </room>
    <room name="Royal Oak">
    </room>
    <room name="The Velvet Room">
      <event id="380">
        <start>18:30</start>
        <duration>02:00</duration>
        <room>The Velvet Room</room>
        <slug>socialouting</slug>
        <title>Major Social Event!</title>
        <subtitle>sponsored by EnterpriseDB</subtitle>
        <track>Social</track>
        <type>other</type>
        <language>en</language>
        <abstract>Come and join us for the major evening social event of PGCon 2011!</abstract>
        <description>EnterpriseDB is sponsoring this event for all PGCon 2011 attendees. Dinner and drinks will be provided. See the map on the website for directions to the venue.


The Velvet Room
62 York St
Ottawa, ON K1N 8Y3

6:30pm-8:30pm</description>
        <persons>
          <person id="1">Dan Langille</person>
        </persons>
        <links>
          <link href="http://goo.gl/maps/at9I">Map</link>
        </links>
      </event>
    </room>
    <room name="DMS 3105">
    </room>
    <room name="DMS 8161">
    </room>
  </day>
  <day date="2011-05-20" index="4">
    <room name="DMS 1140">
      <event id="278">
        <start>10:00</start>
        <duration>01:00</duration>
        <room>DMS 1140</room>
        <slug></slug>
        <title>Android &amp; PostgreSQL</title>
        <subtitle>How to develop an Android App for PostgreSQL</subtitle>
        <track>Applications</track>
        <type>workshop</type>
        <language>en</language>
        <abstract>This is a presentation on how-to develop a simple Android application that uses the PostgreSQL JDBC driver to communicate directly with a database. Use the Android SDK with Eclipse to build and deploy an application.  Familiarity with Java programming and XML recommended.</abstract>
        <description>Learn how to use the Android SDK and Eclipse to develop a simple user interface to connect to a PostgreSQL database and execute simple SQL statements.  Programming tasks include:

* Setting up a development environment
* Executing simple SQL statements
* Executing SQL statements with JDBC Prepared Statements and bind variables
* Using cursors to handle potentially large volumes of data
* Packaging and distributing Android applications</description>
        <persons>
          <person id="23">Mark Wong</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="360">
        <start>11:30</start>
        <duration>01:00</duration>
        <room>DMS 1140</room>
        <slug></slug>
        <title>Advanced WAL file management with OmniPITR. </title>
        <subtitle></subtitle>
        <track>DBA</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>OmniPITR is a set of scripts designed to help manage and maintain WAL files for Postgres database. It was created in an effort to replace the myriad scripts we've encountered, and written, managing our clients Postgres installs over the years. It includes tools for both archiving, restoration, and creating portable backups on both the master and slave instance. </abstract>
        <description>Ever since the advent of PITR in Postgres 8.1, people have been creating 1 off scripts designed to manage PITR and the xlog files that come with it. We've been just as guilty of this as anyone else, making specialized script after script for clients, tweaking for one difference or another. Finally last year we decided we could do better, and OmniPITR was born. 

OmniPITR is a set of scripts designed to help manage and maintain WAL files for Postgres database. It was created in an effort to replace the myriad scripts we've encountered, and written, managing our clients Postgres installs over the years. It includes tools for both archiving, restoration, and creating portable backups on both the master and slave instance. 

Designed to work with Postgres 8.2 and above, we've now replaced a whole mish-mash of scripts with something far more standard and re-usable. Cross platform and Postgres licensed, we have started to see more and more adoption outside of our client base, so we feel comfortable that it's a stable option for many of todays most demanding environments. 
</description>
        <persons>
          <person id="20">Robert Treat</person>
        </persons>
        <links>
          <link href="https://github.com/omniti-labs/omnipitr">OmniPITR source</link>
        </links>
      </event>
      <event id="332">
        <start>13:30</start>
        <duration>01:00</duration>
        <room>DMS 1140</room>
        <slug></slug>
        <title>Doing Bioinformatics in PostgreSQL</title>
        <subtitle></subtitle>
        <track>Applications</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>We introduce and describe two modules that grew from the need to perform
integrated and efficient Bioinformatics tasks in PostgreSQL: PostBio, a set of
methods to store and query genomic sequences and features, and PostStat, a
collection of statistical functions that allow for integrated statistical
tests. A few practical examples will be presented to showcase the modules.</abstract>
        <description>PostBio includes three data types: a GiST-indexable integer interval used to
represent biological sequence features; a suffix tree type to search for
maximum unique matches; and a compressed suffix array for fast short exact
matches. In addition, PostBio provides a set of utilitary sequence routines.

PostStat comprises routines that compute a number of cumulative probability
distributions, linear regression, and statistical tests, both parametric and
non-parametric; the main motivation is to provide a way to test statistical
hypothesis in simple models.</description>
        <persons>
          <person id="193">Luis Carvalho</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="337">
        <start>15:00</start>
        <duration>01:00</duration>
        <room>DMS 1140</room>
        <slug></slug>
        <title>The Write Stuff</title>
        <subtitle>Reaching peak write performance under heavy loads</subtitle>
        <track>Performance</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>One of the most difficult things to do with a database system is handle a high volume of writes, whether it's from a single user or thousands.  The steps a database like PostgreSQL takes to protect your data are expensive, and it's hard to split them into independent pieces.  Recent changes available in the upcoming PostgreSQL 9.1 have given new insight into exactly how PostgreSQL systems that write constantly break down under serious loads.</abstract>
        <description>The replication features in PostgreSQL 9.0 make it easier than ever to scale your application performance up by adding more read-only nodes with additional copies of the data.  But that also makes it easier than ever before to end up running into a harder to resolve write bottleneck as a result.

This talk will cover the major approaches and trade-offs in tuning for high write performance on a PostgreSQL server.  The write-ahead log, checkpoint timing, and buffer management policies of the database all interact to limit just fast data can be shuffled in and out of the server.  Some recently added features to PostgreSQL 9.1 will also be introduced.  These give better insight than was ever available before into exactly what caused the kind of checkpoint write "spikes" that have traditionally plagued write-heavy PostgreSQL databases.  The trade-offs between optimizing for latency and throughput are highlighted when watching operations at this level.

Understanding these problems can help you make the right long-term choices about how to tune system, or provide ammunition for why you need to plan an upgrade to 9.1 when it becomes available in the future.</description>
        <persons>
          <person id="110">Greg Smith</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="286">
        <start>16:30</start>
        <duration>01:00</duration>
        <room>DMS 1140</room>
        <slug></slug>
        <title>Running PostgreSQL in enterprise level telco systems</title>
        <subtitle></subtitle>
        <track>Case Studies</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>A specific example of using  PostgreSQL in enterprise level OSS system for largest pan-russian cellular provider - technology choice reasoning, implementation, maintenance and performance issues.</abstract>
        <description>Solution overview and implementation history. Pessimistic and critical comparison PostgreSQL vs commercial database servers, reasons for choosing PostgreSQL. Expected and unexpected problems using Postgres in the field of telecommunications. Solutions and review of still unsolved difficulties. Postgres specific benefits. All these issues are described in the context of database administration and software development, as well as of interaction with the customer and the vendor.</description>
        <persons>
          <person id="186">Ilya Kosmodemiansky</person>
        </persons>
        <links>
        </links>
      </event>
    </room>
    <room name="DMS 1150">
    </room>
    <room name="DMS 1160">
      <event id="311">
        <start>10:00</start>
        <duration>01:00</duration>
        <room>DMS 1160</room>
        <slug></slug>
        <title>Range Types</title>
        <subtitle>Range Types and Temporal Data</subtitle>
        <track>Advanced Features</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>Range Types are a new feature that captures ranges -- ranges of time, ranges of numbers, ranges of dates -- and gives users the ability to create their own range types. Using Range Types improves performance by using range indexes, simplifies your queries and schema, and enables advanced features such as using Exclusion Constraints to prevent overlap.</abstract>
        <description>Most organizations need to handle range types in one way or another. Ranges of numbers or IP addresses are useful; and of course, ranges of time are perhaps the most common. Explicitly telling PostgreSQL that you are working with ranges -- rather than simulating ranges with a "start" and "end" column -- offers major benefits for functionality (e.g. the ability to prevent overlap), performance (GiST indexing), and ease of use.

We'll walk through some basic examples, compare with the "two-column approach" (that is, using a "beginning" and an "end" column), show the benefits of range types using temporal data as an example, and give a brief overview of how to define your own range types.</description>
        <persons>
          <person id="83">Jeff Davis</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="309">
        <start>11:30</start>
        <duration>01:00</duration>
        <room>DMS 1160</room>
        <slug></slug>
        <title>SP-GiST - a new indexing infrastructure for PostgreSQL</title>
        <subtitle>Space-Partitioning trees in PostgreSQL</subtitle>
        <track>GIS</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>We want to present a prototype of new indexing infrastructure, called SP-GiST, which greatly extends current extendability of PostgreSQL to support space-partitioning trees, as well as a family of digital trees like suffix tree, patricia. We'll present programming interface, examples of realizations of some useful datatypes. Also, we'd like to discuss some implementation issues and roadmap for inclusion to PostgreSQL.</abstract>
        <description>PostgreSQL is known as an extendable database, which means that other than built-in data types can be developed by experts in specific domain, not core programmers. Currently, there are GiST (Generalized Search Tree) and GIN (Generalized Inverted Index) infrastructure in PostgreSQL, which provides extendability with indexing, concurrency and recovery support for user-defined data types. However, these infrastructures are not enough to support a wide class of popular data types, such as space partitioning trees, as well as a family of digital trees like suffix tree, patricia. We present prototype of new indexing infrastucture, called SP-GiST, which adds support of these data types to PostgreSQL. Known implementation of SP-GiST based on academic research paper can't be used in production environment, since it's compatible with rather old version of PostgreSQL and doesn't supports concurrency and recovery, so we propose to develop built-in SP-GiST infrastructure and would like to discuss several implementation issues and development roadmap.</description>
        <persons>
          <person id="29">Oleg Bartunov</person>
          <person id="33">Teodor Sigaev</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="382">
        <start>13:30</start>
        <duration>01:00</duration>
        <room>DMS 1160</room>
        <slug></slug>
        <title>Hacking the Query Planner II</title>
        <subtitle></subtitle>
        <track>Hacking</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>What does the planner do and why does it do it?  How can it be improved? PART II

This is a continuation of Tom's talk from yesterday.</abstract>
        <description>This is a follow-on to Robert Haas's planner talk at PGCon 2010.  I plan to focus more on why and how the planner works, ie, present a developer's-eye view instead of a user's-eye view of what it does.  Topics will include the overall layout of the planner code, preprocessing, join search order, and cost estimation.  Hopefully attendees will come away encouraged to hack on the planner and help improve it.</description>
        <persons>
          <person id="202">Tom Lane</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="291">
        <start>15:00</start>
        <duration>01:00</duration>
        <room>DMS 1160</room>
        <slug></slug>
        <title>Distributing Extensions on PGXN</title>
        <subtitle>Optimal PGXN exposure via Smart distribution packaging</subtitle>
        <track>9.1 Features</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>So you've solved a common problem in PostgreSQL, a serious pain point that lots of other people could take advantage of. You want to open-source the code, and would like to package it up and distribute it where people can find it, read its docs, and download and install it.

The newest destination for distributing PostgreSQL extensions is [PGXN](http://pgxn.org/), the PostgreSQL Extension network. PGXN offers a central index of PostgreSQL extensions and their documentation, making it easy for people to find an install extensions. 

How do you optimize your extension distribution for maximum PGXN exposure? By careful packaging, thorough documentation, and simple installation. Join me for an overview of how best to achieve that &#8212; including how to build extensions compatible with PostgreSQL 9.1's improved extension support.</abstract>
        <description>One of the primary distinguishing features of PostgreSQL&#8212;and perhaps the number one reason to use it instead of another DBMS&#8212;is its extensibility and the large number of database extensions already available. PostgreSQL today is not merely a database, it&#8217;s an application development platform.

So you've solved a common problem in PostgreSQL, a serious pain point that lots of other people could take advantage of. So you've decided to open-source the code, and would like to package it up and distribute it where people can find it, read its docs, and download and install it.

The newest destination for distributing PostgreSQL extensions is [PGXN](http://pgxn.org/), the PostgreSQL Extension network. PGXN offers a central index of PostgreSQL extensions and their documentation, making it easy for people to find an install extensions. 

How do you optimize your extension distribution for maximum PGXN exposure? By careful packaging, thorough documentation, and simple installation. Join me for an overview of how best to achieve that &#8212; including how to build extensions compatible with PostgreSQL 9.1's improved extension support.</description>
        <persons>
          <person id="129">David E. Wheeler</person>
        </persons>
        <links>
          <link href="http://pgxn.org/">PGXN</link>
          <link href="http://manager.pgxn.org/">PGXN Manager</link>
        </links>
      </event>
      <event id="280">
        <start>16:30</start>
        <duration>01:00</duration>
        <room>DMS 1160</room>
        <slug></slug>
        <title>Extensions Development</title>
        <subtitle>both of the feature and developments using it</subtitle>
        <track>9.1 Features</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>PostgreSQL extensibility is remarkable but incomplete. It lacks dump and
restore support. </abstract>
        <description>What that means is  that once an extension is installed
into your database, PostgreSQL currently has no idea of what SQL objects
belongs to  the extension rather  itself, so  the dump will  contain the
instructions to install the extension. That's only practical if you want
to restore  your dump targeting  the very same extension's  version, but
when upgrading systems that's seldom what happens. This talk will detail
how to fix this problem and more, explaining you how to benefit from the
extensions capabilities for your own work within the database.
</description>
        <persons>
          <person id="162">Dimitri Fontaine</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="375">
        <start>17:30</start>
        <duration>01:00</duration>
        <room>DMS 1160</room>
        <slug></slug>
        <title>Closing sessions</title>
        <subtitle>prizes, auctions, fun, games</subtitle>
        <track>Plenary</track>
        <type>other</type>
        <language>en</language>
        <abstract>The Traditional Closing Session</abstract>
        <description>Watch the video.  We raised thousands for charity.</description>
        <persons>
          <person id="1">Dan Langille</person>
        </persons>
        <links>
          <link href="http://www.pgcon.org/2010/audio/32 Closing Session.mp3">audio</link>
        </links>
      </event>
    </room>
    <room name="DMS 1110">
    </room>
    <room name="DMS 1120">
      <event id="344">
        <start>10:00</start>
        <duration>01:00</duration>
        <room>DMS 1120</room>
        <slug></slug>
        <title>Label Based Mandatory Access Control on PostgreSQL</title>
        <subtitle></subtitle>
        <track>9.1 Features</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>PostgreSQL v9.1 shall be released with a long-awaited feature that enables to apply label based mandatory access control. It was primarily developed to integrate security model of SELinux, however, it was evolved to more generic design by community efforts. Nowadays, we can apply an additional security mechanism from a difference perspective in addition to the default database privileges.
This session offers a brief overview of this model, an introduction of what's new in v9.1 and limitations to be overcome in the future release.</abstract>
        <description>This session will be consist of three parts.

The first one is a brief overview of label based mandatory access control; using SELinux as an example.
A key concept is reference monitor model and criteria to make access control decision across heterogeneous object managers; such as filesystem and RDBMS.

The second one is what's new in v9.1.
This version newly provides a basic facilities to manage security labels and security hooks on accesses. It enables us to implement external security provider as a plug-in module; such as SELinux support.

The last one is limitations of the current version and future works.
However, we are still mid-way towards the fully expected functionalities, so we still have several limitations. We will also introduce our roadmap and elemental technologies being necessary to overcome.</description>
        <persons>
          <person id="67">KaiGai Kohei</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="378">
        <start>11:30</start>
        <duration>01:00</duration>
        <room>DMS 1120</room>
        <slug></slug>
        <title>Writeable CTEs</title>
        <subtitle>A Revolution in SQL</subtitle>
        <track>9.1 Features</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>In SQL, Common Table Expressions are a way of creating and using views at run time, but only in read queries. Here we discover ways to use them in writes.

Find out about this exciting new feature!</abstract>
        <description> We can make Common Table Expressions even more powerful than the current SQL standard allows. We might even make it part of a future SQL standard.

Old syntax:

    WITH [RECURSIVE] cte1 [(col[, col...])] AS (
        READ_QUERY
    [(UNION|INTERSECT) [ALL]
        READ_QUERY
    )[, cte2 ...]
    SELECT ...

New syntax:

    WITH [RECURSIVE] cte1 [(col[, col...])] AS (
        ROW_RETURNING_QUERY /* for example, DELETE...RETURNING */
    [(UNION|INTERSECT) [ALL]
        ROW_RETURNING QUERY
    )[, cte2 ...]
    (SELECT|INSERT|UPDATE|DELETE) ...</description>
        <persons>
          <person id="19">David Fetter</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="282">
        <start>13:30</start>
        <duration>01:00</duration>
        <room>DMS 1120</room>
        <slug></slug>
        <title>Exploring Automated Join Construction</title>
        <subtitle>An discussion of HTSQL's join algebra and translation to SQL</subtitle>
        <track>Advanced Features</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>This is advanced talk will be an in-depth discussion of HTSQL's
query language's design, focusing primarily on techniques used
for join specification and translation into SQL.  It should be of
broad interest to core PostgreSQL core developers.  It will likely
not be that useful for application developers or users of HTSQL
since the talk will be focusing on translation mechanics.
</abstract>
        <description>In the notes at the end of the SQL 2003 specification, there is a 
suggested link feature (-&gt; syntax) which could be used to relate 
tables via declared foreign keys.  It's been 8 years and this sort 
of feature still doesn't exist in the core of modern relational 
databases.   It's not because the idea is bad, it's more likely that 
it's because implementing it is non-trivial.

HTSQL has implemented this sort of mechanism in a manner that is
formally defined.   This talk will provide an overview of what 
we've done to get something like this working, the sort of internal
bookkeeping needed and lessons learned. 

The talk will be given by Clark Evans &amp; Kirill Simonov.   

HTSQL is an high-level URI-based relational database query language
designed for accidental programmers.   It is particularly good at
complex reporting and interactive dashboard construction.  HTSQL
was continuously refined over the last 7 years with user feedback
and has become a very useful tool for not only casual database
users, but developers wishing to add ad-hoc query capability to
their application.
</description>
        <persons>
          <person id="86">Clark C. Evans</person>
        </persons>
        <links>
          <link href="http://htsql.org">HTSQL Website</link>
          <link href="http://htsql.org/talks/20110520.html">Slides for 5/20</link>
          <link href="http://">http://</link>
        </links>
      </event>
      <event id="356">
        <start>15:00</start>
        <duration>01:00</duration>
        <room>DMS 1120</room>
        <slug></slug>
        <title>Using PostgreSQL for Flight Planning</title>
        <subtitle>How PostgreSQL is being used at www.worldflightplanner.com</subtitle>
        <track>GIS</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>Postgres is a powerful database, especially when coupling it with PostGIS to make it spatially aware. Using PostgreSQL and PostGIS allows World Flight Planner to provide advanced flight planning tools to both private and commercial pilots.

Using PostgreSQL and PostGIS allows you to access and modify your spatial data using SQL. This talk will provide an overview on the advantages to using PostGIS, how to properly store and query your geographic data, and offer some solutions to common problems.</abstract>
        <description>This talk will comprise:
- A primer on storing geographical data in postgres 
  - Everything you needed to know about projections, sphereoids.
  - Cartesian Trig Vs. Spherical Trig
  - Types of data we need to store (points, line strings, other geometries)
- Why we decided to use Postgres+PostGIS
- How we store global scale meteorological data (converting gridded data in binary format into rows in the postgres database for fast querying)
- Some of the challenges for storing aeronautical information in postgres.
  - How the data was organized in the database (a huge challenge, as  identifiers for airports and navigational aids are not globally unique)
  - Odd airspace shapes (such as pie, or "pac man" shapes)
- Describe the overall relationships of aeronautical data (airports, navigational aids, fixes) with each other.
- Some custom functions we wrote to get the job done.
- Examples of how to use PostGIS functions to do fast computations, such as:
   - Find me the closest airport to my current location.
   - Does my flight path take me through restricted airspace?
   - What heading do I need to take when I cross my next waypoint (bearings).
- Displaying geospatial data, How we did it (map server, mapnik, openlayers,  etc..)
</description>
        <persons>
          <person id="205">Blake Crosby</person>
        </persons>
        <links>
        </links>
      </event>
      <event id="333">
        <start>16:30</start>
        <duration>01:00</duration>
        <room>DMS 1120</room>
        <slug></slug>
        <title>Serializable Snapshot Isolation in Postgres</title>
        <subtitle>Making ISOLATION LEVEL SERIALIZABLE Provide Serializable Isolation</subtitle>
        <track>9.1 Features</track>
        <type>lecture</type>
        <language>en</language>
        <abstract>Serializable isolation makes it easier to reason about database
behavior because concurrent transactions appear to have executed
sequentially. However, Postgres has historically only provided
snapshot isolation, even at the SERIALIZABLE isolation level, which
can expose anomalous states to queries.
</abstract>
        <description>This talk will describe a new SERIALIZABLE isolation level using
Serializable Snapshot Isolation (SSI). Unlike the typical two-phase
locking approach to serializability, SSI uses the existing snapshot
isolation mechanisms and retains most of their performance benefits.
It adds a new type of lock that's used to track read dependencies and
roll back transactions when dangerous structures appear in the
serialization graph, indicating possible anomalies.

We'll describe how SSI works and how we've implemented it for Postgres
9.1, including a new predicate lock manager. We'll explain what users
can expect when using the new SERIALIZABLE mode, and present some
performance results.</description>
        <persons>
          <person id="197">Dan Ports</person>
          <person id="113">Kevin Grittner</person>
        </persons>
        <links>
        </links>
      </event>
    </room>
    <room name="Out and about">
    </room>
    <room name="Royal Oak">
    </room>
    <room name="The Velvet Room">
    </room>
    <room name="DMS 3105">
    </room>
    <room name="DMS 8161">
    </room>
  </day>
  <day date="2011-05-21" index="5">
    <room name="DMS 1140">
    </room>
    <room name="DMS 1150">
    </room>
    <room name="DMS 1160">
    </room>
    <room name="DMS 1110">
      <event id="374">
        <start>09:30</start>
        <duration>04:00</duration>
        <room>DMS 1110</room>
        <slug>pldevs</slug>
        <title>PL Developer Summit</title>
        <subtitle>PL/Mania</subtitle>
        <track>Community</track>
        <type>meeting</type>
        <language>en</language>
        <abstract>Procedural Language</abstract>
        <description>Eevelopers will met and discuss current issues around PLs</description>
        <persons>
          <person id="112">Selena Deckelmann</person>
        </persons>
        <links>
        </links>
      </event>
    </room>
    <room name="DMS 1120">
    </room>
    <room name="Out and about">
      <event id="376">
        <start>10:00</start>
        <duration>05:00</duration>
        <room>Out and about</room>
        <slug>tourist</slug>
        <title>Tourist stuff</title>
        <subtitle>Spend some time exploring</subtitle>
        <track>Social</track>
        <type>other</type>
        <language>en</language>
        <abstract>Explore Ottawa</abstract>
        <description>Ottawa has a large number of great attractions.  Spend some time looking around and explore.  Spend as much time as you want with us, or leave early.  We will walk everywhere we go.  Wear sensible shoes. Bring your camera.  We'll probably have lunch somewhere along the way.  Consider the weather (sun block, rain coat, umbrella, swim suit).

This is one option for Saturday. You are free to come with us or take part in all or some activities.  Or make your own way around...

The agenda for the tourist day is completely wrong.

The forecast: http://www.theweathernetwork.com/weather/CAON0512

Cora's - 8 AM - Breakfast
 - 179 Rideau Street - http://bit.ly/dngpnV
 - if you arrive much past 8:30, you probably won't get
   through in time to get to the next meeting point
 - we will depart Cora's at 8:55

Rideau Center - 9:13
 - south end of the Mall on the Mackenzie King bridge
 - we are catching the #95 bus to direction Orleans to BLAIR 1B
 - from there, at 9:27, take Bus route 129 (OC Transpo) direction 
   Aviation

Aviation Museum
 - we'll do a guided tour first, then wander around
 - departing here at 1:30

Earl of Sussex Pub
 - arriving at about 2:15
 - 431 Sussex Drive
   Ottawa, ON K1N 9M6
   (613) 562-5544
   earlofsussex.ca

All times after we leave Rideau Center are very subject to change.
</description>
        <persons>
          <person id="1">Dan Langille</person>
        </persons>
        <links>
          <link href="http://maps.google.ca/maps/ms?ie=UTF8&amp;hl=en&amp;t=h&amp;msa=0&amp;msid=115376119403106089489.0004815ec7a3ab52418a4&amp;ll=45.423802,-75.693988&amp;spn=0.00372,0.006899&amp;z=17&amp;iwloc=0004815ec9b5358e264ea">National Memorial</link>
          <link href="http://maps.google.ca/maps/ms?ie=UTF8&amp;hl=en&amp;t=h&amp;msa=0&amp;msid=115376119403106089489.0004815ec7a3ab52418a4&amp;ll=45.422733,-75.683624&amp;spn=0.00372,0.006899&amp;z=17&amp;iwloc=0004815ec9b533f6ce56d">Residence</link>
          <link href="http://www.pgcon.org/phorum/list.php?f=6">Forum</link>
        </links>
      </event>
    </room>
    <room name="Royal Oak">
    </room>
    <room name="The Velvet Room">
    </room>
    <room name="DMS 3105">
    </room>
    <room name="DMS 8161">
    </room>
  </day>
</schedule>
