{"success":true,"data":{"query":"PostgreSQL 18.4 Documentation","limit":10,"count":10,"sources":["wiki_real_estate.hat","web_1779060034.hat","web_1779060041.hat","web_1779060046.hat","web_1779060040.hat","postgres_mastery.tah"],"synced":[],"results":[{"source":"wiki_real_estate.hat","text":"ARTICLE: Cadastre\nA cadastre or cadaster ( kə-DAS-tər) is a comprehensive recording of the real estate or real property's metes-and-bounds of a country. Often it is represented graphically in a cadastral map, though historical written accounts, such as the Domesday Book in England in 1086, were early examples of cadastre.\nIn most countries, legal systems have developed around original administrative systems and use the cadastre to define the dimensions and location of land parcels described in legal documentation. A land parcel or cadastral parcel is defined as \"a continuous area, or more appropriately volume, that is identified by a unique set of homogeneous property rights\".\nCadastral surveys document the boundaries of land ownership, by the production of documents, diagrams, sketches, plans (plats in the US), charts, and maps. They were originally used to ensure reliable facts for land valuation and taxation. Cadastral survey information is often a base element in Geographic Information Systems (GIS) or Land Information Systems (LIS) used to assess and manage land and built infrastructure. Such systems are also employed on a variety of other tasks, for example, to track long-term changes over time for geological or ecological studies, where land tenure is a significant part of the scenario.\nThe cadastre is a fundamental source of data in disputes and lawsuits between landowners. Land registration and cadastre are both types of land recording and complement each other. Under his code, Napoleon established a comprehensive cadastral system for France that is regarded as the forerunner of most modern versions.\nBy allowing for the clear assignment of rights to property, and demarcating and delimiting parcels of land, cadasters have been credited with strengthening the financial independence of land owners, facilitating economic risk taking and in turn growth in output and employment, and improving state fiscal capacity (through, for example, improved tax collection and more properly valued real estate markets).","score":27.551529804882808,"links":[]},{"source":"wiki_real_estate.hat","text":"Documentation\nCadastral documentation comprises the documentary materials submitted to cadastre or land administration offices for renewal of cadastral recordings. Cadastral documentation is kept in paper and/or electronic form.  Jurisdiction statutes and further provisions specify the content and form of the documentation, as well as the person(s) authorized to prepare and sign the documentation, including concerned parties (owner, etc.), licensed surveyors and legal advisors. The office concerned reviews the submitted information; if the documentation does not comply with stated provisions, the office may set a deadline for the applicant to submit complete documentation.\nThe concept of cadastral documentation emerged late in the English language, as the institution of cadastre developed outside English-speaking countries. In a Danish textbook, one out of fifteen chapters regards the form and content of documents concerning subdivision and other land matters. Early textbooks of international scope focused on recordings in terms of land registration and technical aspects of cadastral survey, yet note that 'cadastral surveying has been carried out within a tight framework of legislation'. With the view of assessing transaction costs, a European project: Modelling real property transactions (2001–2005) charted procedures for the transfer of ownership and other rights in land and buildings. Cadastral documentation is described, e.g. for Finland as follows '8. Surveyor draws up cadastral map and cadastral documents … 10. Surveyor sends cadastral documents to cadastral authority.'  In Australia, similar activities are referred to as 'lodgement of plans of subdivision at land titles offices'","score":27.551529804882808,"links":[]},{"source":"web_1779060034.hat","text":"Menu Using App Router Features available in /app Latest Version 16.2.6 For an index of Next.js documentation , see /docs/llms.txt . Next.js Docs Welcome to the Next.js documentation! What is Next.js? Next.js is a React framework for building full-stack web applications. You use React Components to build user interfaces, and Next.js for additional features and optimizations. It also automatically configures lower-level tools like bundlers and compilers. You can instead focus on building your product and shipping quickly. Whether you're an individual developer or part of a larger team, Next.js can help you build interactive, dynamic, and fast React applications. How to use the docs The docs are organized into 3 sections: Getting Started : Step-by-step tutorials to help you create a new application and learn the core Next.js features. Guides : Tutorials on specific use cases, choose what's relevant to you. API Reference : Detailed technical reference for every feature. Use the sidebar to navigate through the sections, or search ( Ctrl+K or Cmd+K ) to quickly find a page. App Router and Pages Router Next.js has two different routers: App Router : The newer router that supports new React features like Server Components. Pages Router : The original router, still supported and being improved. At the top of the sidebar, you'll notice a dropdown menu that allows you to switch between the App Router and the Pages Router docs. React version handling The App Router and Pages Router handle React versions differently: App Router : Uses React canary releases built-in, which include all the stable React 19 changes, as well as newer features being validated in frameworks, prior to a new React release. Pages Router : Uses the React version installed in your project's package.json . This approach ensures new React features work reliably in the App Router while maintaining backwards compatibility for existing Pages Router applications. Pre-requisite knowledge Our documentation assumes some familiarity with web development. Before getting started, it'll help if you're comfortable with: HTML CSS JavaScript React If you're new to React or need a refresher, we recommend starting with our React Foundations course , and the Next.js Foundations course that has you building an application as you learn. Accessibility For the best experience when using a screen reader, we recommend using Firefox and NVDA, or Safari and VoiceOver. Join our Community If you have questions about anything related to Next.js, you're always welcome to ask our community on GitHub Discussions , Discord , X (Twitter) , and Reddit . Next Steps Create your first application and learn the core Next.js features. Getting Started Learn how to create full-stack web applications with the Next.js App Router. Was this helpful? supported. Send","score":27.12400931168676,"links":[]},{"source":"web_1779060034.hat","text":"Menu Using App Router Features available in /app Latest Version 16.2.6 This page is also available as Markdown at /docs/app/getting-started.md . For an index of Next.js documentation , see /docs/llms.txt . Copy page Getting Started Last updated May 13, 2026 Welcome to the Next.js documentation! This Getting Started section will help you create your first Next.js app and learn the core features you'll use in every project. Pre-requisite knowledge Our documentation assumes some familiarity with web development. Before getting started, it'll help if you're comfortable with: HTML CSS JavaScript React If you're new to React or need a refresher, we recommend starting with our React Foundations course , and the Next.js Foundations course that has you building an application as you learn. Next Steps Installation Learn how to create a new Next.js application with the `create-next-app` CLI, and set up TypeScript, ESLint, and Module Path Aliases. Project Structure Learn the folder and file conventions in Next.js, and how to organize your project. Layouts and Pages Learn how to create your first pages and layouts, and link between them with the Link component. Linking and Navigating Learn how the built-in navigation optimizations work, including prefetching, prerendering, and client-side navigation, and how to optimize navigation for dynamic routes and slow networks. Server and Client Components Learn how you can use React Server and Client Components to render parts of your application on the server or the client. Fetching Data Learn how to fetch data and stream content that depends on data. Mutating Data Learn how to mutate data using Server Functions and Server Actions in Next.js. Caching Learn how to cache data and UI in Next.js Revalidating Learn how to revalidate cached data using time-based and on-demand strategies. Error Handling Learn how to display expected errors and handle uncaught exceptions. CSS Learn about the different ways to add CSS to your application, including Tailwind CSS, CSS Modules, Global CSS, and more. Image Optimization Learn how to optimize images in Next.js Font Optimization Learn how to optimize fonts in Next.js Metadata and OG images Learn how to add metadata to your pages and create dynamic OG images. Route Handlers Learn how to use Route Handlers Proxy Learn how to use Proxy Deploying Learn how to deploy your Next.js application. Upgrading Learn how to upgrade your Next.js application to the latest version or canary. Was this helpful? supported. Send","score":27.12400931168676,"links":[]},{"source":"web_1779060034.hat","text":"Menu Using App Router Features available in /app Latest Version 16.2.6 This page is also available as Markdown at /docs/app/guides.md . For an index of Next.js documentation , see /docs/llms.txt . Copy page Guides Last updated May 13, 2026 AI Coding Agents Learn how to configure your Next.js project so AI coding agents use up-to-date documentation instead of outdated training data. Analytics Measure and track page performance using Next.js Speed Insights Authentication Learn how to implement authentication in your Next.js application. Backend for Frontend Learn how to use Next.js as a backend framework Caching (Previous Model) Learn how to cache and revalidate data using fetch options, unstable_cache, and route segment configs for projects not using Cache Components. CDN Caching Learn how CDN caching works with Next.js, including what works today, cache variability, and the direction toward pathname-based cache keying. CI Build Caching Learn how to configure CI to cache Next.js builds Content Security Policy Learn how to set a Content Security Policy (CSP) for your Next.js application. CSS-in-JS Use CSS-in-JS libraries with Next.js Custom Server Start a Next.js app programmatically using a custom server. Data Security Learn the built-in data security features in Next.js and learn best practices for protecting your application's data. Debugging Learn how to debug your Next.js application with VS Code, Chrome DevTools, or Firefox DevTools. Deploying to Platforms Understand which Next.js features require specific platform capabilities and how to choose the right deployment target. Draft Mode Next.js has draft mode to toggle between static and dynamic pages. You can learn how it works with App Router here. Environment Variables Learn to add and access environment variables in your Next.js application. Forms Learn how to create forms in Next.js with React Server Actions. How Revalidation Works A deep dive into how Next.js revalidates cached content, including the tag system, cache consistency, and multi-instance coordination. ISR Learn how to create or update static pages at runtime with Incremental Static Regeneration. Instrumentation Learn how to use instrumentation to run code at server startup in your Next.js app Internationalization Add support for multiple languages with internationalized routing and localized content. JSON-LD Learn how to add JSON-LD to your Next.js application to describe your content to search engines and AI. Lazy Loading Lazy load imported libraries and React Components to improve your application's loading performance. Development Environment Learn how to optimize your local development environment with Next.js. Next.js MCP Server Learn how to use Next.js MCP support to allow coding agents access to your application state MDX Learn how to configure MDX and use it in your Next.js apps. Memory Usage Optimize memory used by your application in development and production. Migrating Learn how to migrate from popular frameworks to Next.js Migrating to Cache Components Learn how to migrate from route segment configs to Cache Components in Next.js. Multi-tenant Learn how to build multi-tenant apps with the App Router. Multi-zones Learn how to build micro-frontends using Next.js Multi-Zones to deploy multiple Next.js apps under a single domain. OpenTelemetry Learn how to instrument your Next.js app with OpenTelemetry. Package Bundling Learn how to analyze and optimize your application's server and client bundles with the Next.js Bundle Analyzer for Turbopack, and the `@next/bundle-analyzer` plugin for Webpack. PPR Platform Guide A guide for platform engineers on implementing PPR support, from basic origin rendering to optimized CDN integration. Prefetching Learn how to configure prefetching in Next.js Preserving UI state Learn how React's Activity component preserves UI state across navigations in Next.js and how to control what resets. Preventing Flash Learn how to correct server-rendered content before the browser paints, avoiding visible flash when the page hydrates. Production Recommendations to ensure the best performance and user experience before taking your Next.js application to production. PWAs Learn how to build a Progressive Web Application (PWA) with Next.js. Public pages Learn how to build public, \"static\" pages that share data across users, such as landing pages, list pages (products, blogs, etc.), marketing and news sites. Redirecting Learn the different ways to handle redirects in Next.js. Rendering Philosophy Learn how Next.js treats static and dynamic rendering as a spectrum at the component level, and what this means for deployment. Sass Style your Next.js application using Sass. Scripts Optimize 3rd party scripts with the built-in Script component. Self-Hosting Learn how to self-host your Next.js application on a Node.js server, Docker image, or static HTML files (static exports). SPAs Next.js fully supports building Single-Page Applications (SPAs). Static Exports Next.js enables starting as a static site or Single-Page Application (SPA), then later optionally upgrading to use features that require a server. Streaming Learn how streaming works in Next.js and how to use it to progressively render UI as data becomes available. Tailwind CSS v3 Style your Next.js Application using Tailwind CSS v3 for broader browser support. Testing Learn how to set up Next.js with four commonly used testing tools — Cypress, Playwright, Vitest, and Jest. Third Party Libraries Optimize the performance of third-party libraries in your application with the `@next/third-parties` package. Upgrading Learn how to upgrade to the latest versions of Next.js. Videos Recommendations and best practices for optimizing videos in your Next.js application. View transitions Learn how to use view transitions to communicate meaning during navigation, loading, and content changes in a Next.js app. Was this helpful? supported. Send","score":27.12400931168676,"links":[]},{"source":"web_1779060041.hat","text":"Supabase Documentation Learn how to get up and running with Supabase through tutorials, APIs and platform resources. Getting Started Set up and connect a database in just a few minutes. Start with Supabase AI prompts Products Database Supabase provides a full Postgres database for every project with Realtime functionality, database backups, extensions, and more. Auth Add and manage email and password, passwordless, OAuth, and mobile logins to your project through a suite of identity providers and APIs. Storage Store, organize, transform, and serve large files—fully integrated with your Postgres database with Row Level Security access policies. Realtime Listen to database changes, store and sync user states across clients, broadcast data to clients subscribed to a channel, and more. Edge Functions Globally distributed, server-side functions to execute your code closest to your users for the lowest latency. Modules AI & Vectors Cron Queues Data REST API GraphQL API Client Libraries JavaScript Flutter Python C# Swift Kotlin Migrate to Supabase Bring your existing data, auth and storage to Supabase following our migration guides. Explore more resources about /guides/resources Explore more resources Amazon RDS Auth0 Firebase Auth Firebase Storage Firestore Data Heroku MSSQL MySQL Neon Postgres Render Vercel Postgres Additional resources AI tools Develop with Supabase AI-first using plugins, MCP, and skills. Platform guides Learn more about the tools and services powering Supabase. Supabase CLI Use the CLI to develop, manage and deploy your projects. Management API Manage your Supabase projects and organizations. Integrations Explore a variety of integrations from Supabase partners. Supabase UI A collection of pre-built Supabase components to speed up your project. Troubleshooting Our troubleshooting guide for solutions to common Supabase issues. Self-Hosting Get started with self-hosting Supabase. More on Self-Hosting about /guides/self-hosting More on Self-Hosting Auth Realtime Storage Analytics","score":27.12400931168676,"links":[]},{"source":"web_1779060046.hat","text":"API Reference Copy page Copy React Reference Overview This section provides detailed reference documentation for working with React. For an introduction to React, please visit the Learn section. The React reference documentation is broken down into functional subsections: React Programmatic React features: Hooks - Use different React features from your components. Components - Built-in components that you can use in your JSX. APIs - APIs that are useful for defining components. Directives - Provide instructions to bundlers compatible with React Server Components. React DOM React DOM contains features that are only supported for web applications (which run in the browser DOM environment). This section is broken into the following: Hooks - Hooks for web applications which run in the browser DOM environment. Components - React supports all of the browser built-in HTML and SVG components. APIs - The react-dom package contains methods supported only in web applications. Client APIs - The react-dom/client APIs let you render React components on the client (in the browser). Server APIs - The react-dom/server APIs let you render React components to HTML on the server. Static APIs - The react-dom/static APIs let you generate static HTML for React components. React Compiler The React Compiler is a build-time optimization tool that automatically memoizes your React components and values: Configuration - Configuration options for React Compiler. Directives - Function-level directives to control compilation. Compiling Libraries - Guide for shipping pre-compiled library code. ESLint Plugin React Hooks The ESLint plugin for React Hooks helps enforce the Rules of React: Lints - Detailed documentation for each lint with examples. Rules of React React has idioms — or rules — for how to express patterns in a way that is easy to understand and yields high-quality applications: Components and Hooks must be pure – Purity makes your code easier to understand, debug, and allows React to automatically optimize your components and hooks correctly. React calls Components and Hooks – React is responsible for rendering components and hooks when necessary to optimize the user experience. Rules of Hooks – Hooks are defined using JavaScript functions, but they represent a special type of reusable UI logic with restrictions on where they can be called. Legacy APIs Legacy APIs - Exported from the react package, but not recommended for use in newly written code. Next Hooks","score":27.12400931168676,"links":[]},{"source":"web_1779060046.hat","text":"Learn React Copy page Copy Quick Start Welcome to the React documentation! This page will give you an introduction to 80% of the React concepts that you will use on a daily basis. You will learn How to create and nest components How to add markup and styles How to display data How to render conditions and lists How to respond to events and update the screen How to share data between components Creating and nesting components React apps are made out of components . A component is a piece of the UI (user interface) that has its own logic and appearance. A component can be as small as a button, or as large as an entire page. React components are JavaScript functions that return markup: function MyButton ( ) { return ( < button > I'm a button </ button > ) ; } Now that you’ve declared MyButton , you can nest it into another component: export default function MyApp ( ) { return ( < div > < h1 > Welcome to my app </ h1 > < MyButton /> </ div > ) ; } Notice that <MyButton /> starts with a capital letter. That’s how you know it’s a React component. React component names must always start with a capital letter, while HTML tags must be lowercase. Have a look at the result: App.js App.js Reload Clear Fork function MyButton ( ) { return ( < button > I'm a button </ button > ) ; } export default function MyApp ( ) { return ( < div > < h1 > Welcome to my app </ h1 > < MyButton /> </ div > ) ; } Show more The export default keywords specify the main component in the file. If you’re not familiar with some piece of JavaScript syntax, MDN and javascript.info have great references. Writing markup with JSX The markup syntax you’ve seen above is called JSX . It is optional, but most React projects use JSX for its convenience. All of the tools we recommend for local development support JSX out of the box. JSX is stricter than HTML. You have to close tags like <br /> . Your component also can’t return multiple JSX tags. You have to wrap them into a shared parent, like a <div>...</div> or an empty <>...</> wrapper: function AboutPage ( ) { return ( < > < h1 > About </ h1 > < p > Hello there. < br /> How do you do? </ p > </ > ) ; } If you have a lot of HTML to port to JSX, you can use an online converter. Adding styles In React, you specify a CSS class with className . It works the same way as the HTML class attribute: < img className = \"avatar\" /> Then you write the CSS rules for it in a separate CSS file: /* In your CSS */ .avatar { border-radius : 50 % ; } React does not prescribe how you add CSS files. In the simplest case, you’ll add a <link> tag to your HTML. If you use a build tool or a framework, consult its documentation to learn how to add a CSS file to your project. Displaying data JSX lets you put markup into JavaScript. Curly braces let you “escape back” into JavaScript so that you can embed some variable from your code and display it to the user. For example, this will display user.name : return ( < h1 > { user . name } </ h1 > ) ; You can also “escape into JavaScript” from JSX attributes, but you have to use curly braces instead of quotes. For example, className=\"avatar\" passes the \"avatar\" string as the CSS class, but src={user.imageUrl} reads the JavaScript user.imageUrl variable value, and then passes that value as the src attribute: return ( < img className = \"avatar\" src = { user . imageUrl } /> ) ; You can put more complex expressions inside the JSX curly braces too, for example, string concatenation : App.js App.js Reload Clear Fork const user = { name : 'Hedy Lamarr' , imageUrl : 'https://react.dev/images/docs/scientists/yXOvdOSs.jpg' , imageSize : 90 , } ; export default function Profile ( ) { return ( < > < h1 > { user . name } </ h1 > < img className = \"avatar\" src = { user . imageUrl } alt = { 'Photo of ' + user . name } style = { { width : user . imageSize , height : user . imageSize } } /> </ > ) ; } Show more In the above example, style={{}} is not a special syntax, but a regular {} object inside the style={ } JSX curly braces. You can use the style attribute when your styles depend on JavaScript variables. Conditional rendering In React, there is no special syntax for writing conditions. Instead, you’ll use the same techniques as you use when writing regular JavaScript code. For example, you can use an if statement to conditionally include JSX: let content ; if ( isLoggedIn ) { content = < AdminPanel /> ; } else { content = < LoginForm /> ; } return ( < div > { content } </ div > ) ; If you prefer more compact code, you can use the conditional ? operator. Unlike if , it works inside JSX: < div > { isLoggedIn ? ( < AdminPanel /> ) : ( < LoginForm /> ) } </ div > When you don’t need the else branch, you can also use a shorter logical && syntax : < div > { isLoggedIn && < AdminPanel /> } </ div > All of these approaches also work for conditionally specifying attributes. If you’re unfamiliar with some of this JavaScript syntax, you can start by always using if...else . Rendering lists You will rely on JavaScript features like for loop and the array map() function to render lists of components. For example, let’s say you have an array of products: const products = [ { title : 'Cabbage' , id : 1 } , { title : 'Garlic' , id : 2 } , { title : 'Apple' , id : 3 } , ] ; Inside your component, use the map() function to transform an array of products into an array of <li> items: const listItems = products . map ( product => < li key = { product . id } > { product . title } </ li > ) ; return ( < ul > { listItems } </ ul > ) ; Notice how <li> has a key attribute. For each item in a list, you should pass a string or a number that uniquely identifies that item among its siblings. Usually, a key should be coming from your data, such as a database ID. React uses your keys to know what happened if you later insert, delete, or reorder the items. App.js App.js Reload Clear Fork const products = [ { title : 'Cabbage' , isFruit : false , id : 1 } , { title : 'Garlic' , isFruit : false , id : 2 } , { title : 'Apple' , isFruit : true , id : 3 } , ] ; export default function ShoppingList ( ) { const listItems = products . map ( product => < li key = { product . id } style = { { color : product . isFruit ? 'magenta' : 'darkgreen' } } > { product . title } </ li > ) ; return ( < ul > { listItems } </ ul > ) ; } Show more Responding to events You can respond to events by declaring event handler functions inside your components: function MyButton ( ) { function handleClick ( ) { alert ( 'You clicked me!' ) ; } return ( < button onClick = { handleClick } > Click me </ button > ) ; } Notice how onClick={handleClick} has no parentheses at the end! Do not call the event handler function: you only need to pass it down . React will call your event handler when the user clicks the button. Updating the screen Often, you’ll want your component to “remember” some information and display it. For example, maybe you want to count the number of times a button is clicked. To do this, add state to your component. First, import useState from React: import { useState } from 'react' ; Now you can declare a state variable inside your component: function MyButton ( ) { const [ count , setCount ] = useState ( 0 ) ; // ... You’ll get two things from useState : the current state ( count ), and the function that lets you update it ( setCount ). You can give them any names, but the convention is to write [something, setSomething] . The first time the button is displayed, count will be 0 because you passed 0 to useState() . When you want to change state, call setCount() and pass the new value to it. Clicking this button will increment the counter: function MyButton ( ) { const [ count , setCount ] = useState ( 0 ) ; function handleClick ( ) { setCount ( count + 1 ) ; } return ( < button onClick = { handleClick } > Clicked { count } times </ button > ) ; } React will call your component function again. This time, count will be 1 . Then it will be 2 . And so on. If you render the same component multiple times, each will get its own state. Click each button separately: App.js App.js Reload Clear Fork import { useState } from 'react' ; export default function MyApp ( ) { return ( < div > < h1 > Counters that update separately </ h1 > < MyButton /> < MyButton /> </ div > ) ; } function MyButton ( ) { const [ count , setCount ] = useState ( 0 ) ; function handleClick ( ) { setCount ( count + 1 ) ; } return ( < button onClick = { handleClick } > Clicked { count } times </ button > ) ; } Show more Notice how each button “remembers” its own count state and doesn’t affect other buttons. Using Hooks Functions starting with use are called Hooks . useState is a built-in Hook provided by React. You can find other built-in Hooks in the API reference. You can also write your own Hooks by combining the existing ones. Hooks are more restrictive than other functions. You can only call Hooks at the top of your components (or other Hooks). If you want to use useState in a condition or a loop, extract a new component and put it there. Sharing data between components In the previous example, each MyButton had its own independent count , and when each button was clicked, only the count for the button clicked changed: Initially, each MyButton ’s count state is 0 The first MyButton updates its count to 1 However, often you’ll need components to share data and always update together . To make both MyButton components display the same count and update together, you need to move the state from the individual buttons “upwards” to the closest component containing all of them. In this example, it is MyApp : Initially, MyApp ’s count state is 0 and is passed down to both children On click, MyApp updates its count state to 1 and passes it down to both children Now when you click either button, the count in MyApp will change, which will change both of the counts in MyButton . Here’s how you can express this in code. First, move the state up from MyButton into MyApp : export default function MyApp ( ) { const [ count , setCount ] = useState ( 0 ) ; function handleClick ( ) { setCount ( count + 1 ) ; } return ( < div > < h1 > Counters that update separately </ h1 > < MyButton /> < MyButton /> </ div > ) ; } function MyButton ( ) { // ... we're moving code from here ... } Then, pass the state down from MyApp to each MyButton , together with the shared click handler. You can pass information to MyButton using the JSX curly braces, just like you previously did with built-in tags like <img> : export default function MyApp ( ) { const [ count , setCount ] = useState ( 0 ) ; function handleClick ( ) { setCount ( count + 1 ) ; } return ( < div > < h1 > Counters that update together </ h1 > < MyButton count = { count } onClick = { handleClick } /> < MyButton count = { count } onClick = { handleClick } /> </ div > ) ; } The information you pass down like this is called props . Now the MyApp component contains the count state and the handleClick event handler, and passes both of them down as props to each of the buttons. Finally, change MyButton to read the props you have passed from its parent component: function MyButton ( { count , onClick } ) { return ( < button onClick = { onClick } > Clicked { count } times </ button > ) ; } When you click the button, the onClick handler fires. Each button’s onClick prop was set to the handleClick function inside MyApp , so the code inside of it runs. That code calls setCount(count + 1) , incrementing the count state variable. The new count value is passed as a prop to each button, so they all show the new value. This is called “lifting state up”. By moving state up, you’ve shared it between components. App.js App.js Reload Clear Fork import { useState } from 'react' ; export default function MyApp ( ) { const [ count , setCount ] = useState ( 0 ) ; function handleClick ( ) { setCount ( count + 1 ) ; } return ( < div > < h1 > Counters that update together </ h1 > < MyButton count = { count } onClick = { handleClick } /> < MyButton count = { count } onClick = { handleClick } /> </ div > ) ; } function MyButton ( { count , onClick } ) { return ( < button onClick = { onClick } > Clicked { count } times </ button > ) ; } Show more Next Steps By now, you know the basics of how to write React code! Check out the Tutorial to put them into practice and build your first mini-app with React. Next Tutorial: Tic-Tac-Toe","score":27.12400931168676,"links":[]},{"source":"web_1779060040.hat","text":"PostgreSQL 18.4 Documentation Next PostgreSQL 18.4 Documentation The PostgreSQL Global Development Group Copyright © 1996–2026 The PostgreSQL Global Development Group Legal Notice Table of Contents Preface 1. What Is PostgreSQL ? 2. A Brief History of PostgreSQL 3. Conventions 4. Further Information 5. Bug Reporting Guidelines I. Tutorial 1. Getting Started 2. The SQL Language 3. Advanced Features II. The SQL Language 4. SQL Syntax 5. Data Definition 6. Data Manipulation 7. Queries 8. Data Types 9. Functions and Operators 10. Type Conversion 11. Indexes 12. Full Text Search 13. Concurrency Control 14. Performance Tips 15. Parallel Query III. Server Administration 16. Installation from Binaries 17. Installation from Source Code 18. Server Setup and Operation 19. Server Configuration 20. Client Authentication 21. Database Roles 22. Managing Databases 23. Localization 24. Routine Database Maintenance Tasks 25. Backup and Restore 26. High Availability, Load Balancing, and Replication 27. Monitoring Database Activity 28. Reliability and the Write-Ahead Log 29. Logical Replication 30. Just-in-Time Compilation ( JIT ) 31. Regression Tests IV. Client Interfaces 32. libpq — C Library 33. Large Objects 34. ECPG — Embedded SQL in C 35. The Information Schema V. Server Programming 36. Extending SQL 37. Triggers 38. Event Triggers 39. The Rule System 40. Procedural Languages 41. PL/pgSQL — SQL Procedural Language 42. PL/Tcl — Tcl Procedural Language 43. PL/Perl — Perl Procedural Language 44. PL/Python — Python Procedural Language 45. Server Programming Interface 46. Background Worker Processes 47. Logical Decoding 48. Replication Progress Tracking 49. Archive Modules 50. OAuth Validator Modules VI. Reference I. SQL Commands II. PostgreSQL Client Applications III. PostgreSQL Server Applications VII. Internals 51. Overview of PostgreSQL Internals 52. System Catalogs 53. System Views 54. Frontend/Backend Protocol 55. PostgreSQL Coding Conventions 56. Native Language Support 57. Writing a Procedural Language Handler 58. Writing a Foreign Data Wrapper 59. Writing a Table Sampling Method 60. Writing a Custom Scan Provider 61. Genetic Query Optimizer 62. Table Access Method Interface Definition 63. Index Access Method Interface Definition 64. Write Ahead Logging for Extensions 65. Built-in Index Access Methods 66. Database Physical Storage 67. Transaction Processing 68. System Catalog Declarations and Initial Contents 69. How the Planner Uses Statistics 70. Backup Manifest Format VIII. Appendixes A. PostgreSQL Error Codes B. Date/Time Support C. SQL Key Words D. SQL Conformance E. Release Notes F. Additional Supplied Modules and Extensions G. Additional Supplied Programs H. External Projects I. The Source Code Repository J. Documentation K. PostgreSQL Limits L. Acronyms M. Glossary N. Color Support O. Obsolete or Renamed Features Bibliography Index Next Preface","score":26.09969518892752,"links":[]},{"source":"postgres_mastery.tah","text":"PostgreSQL Performance: Use EXPLAIN (ANALYZE, BUFFERS) for query profiling. In serverless (Next.js), always use Supavisor (Transaction mode) to prevent connection exhaustion. Indexing: Use Covering Indexes (INCLUDE) for Index-Only scans. Anti-Patterns: Avoid 'SELECT *' and 'COUNT(*)' on large tables; use caching for counts.","score":15,"links":[]}]},"metadata":{},"timestamp":"2026-07-08T22:49:54.936Z"}